extension VideoSectionController: IGListScrollDelegate {

    // MARK: - GListScrollDelegate

    func listAdapter(_ listAdapter: IGListAdapter!, didScroll sectionController: IGListSectionController!) {

    }

    func listAdapter(_ listAdapter: IGListAdapter!, willBeginDragging sectionController: IGListSectionController!) {

    }

    func listAdapter(_ listAdapter: IGListAdapter!, didEndDragging sectionController: IGListSectionController!, willDecelerate decelerate: Bool) {

        guard var cells = self.collectionContext?.visibleCells(for: sectionController) as? [VideoCell] else { return }

        // cells 重新排序
        cells = cells.sorted { (cell0, cell1) -> Bool in
            guard let indexPath0 = collectionContext?.index(for: cell0, sectionController: sectionController) else {
                return true
            }
            guard let indexPath1 = collectionContext?.index(for: cell1, sectionController: sectionController) else {
                return true
            }

            if indexPath0 < indexPath1 {
                return true
            } else {
                return false
            }

        }
        
        for cell in cells {
        
            let videoCenter = cell.convert(cell.videoCoverImageView.center, to: nil)

            if videoCenter.y < 64 {
                // pause
                cell.pause()
            } else {
                // play
                cell.play()
                break
            }
        }

    }
}

override func didMove(toParentViewController parent: UIViewController?) {
    super.didMove(toParentViewController: parent)

    if parent == self.navigationController?.parent {
        print("Back tapped")
        NotificationCenter.default.post(name: Notification.Name.VideoPlayer.VideoCellStopPlay, object: nil, userInfo: nil)
    }
}

import UIKit

class ButtonView: UIView {

    var image: UIImage? {
        didSet {
            if imageView == nil {
                imageView = UIImageView()
                imageView?.backgroundColor = .clear
                imageView?.layer.masksToBounds = true
                self.insertSubview(imageView!, at: 0)
            }
            imageView?.image = image
        }
    }

    private var imageView: UIImageView?

    override func draw(_ rect: CGRect) {
		// 重点代码，一行即可完成
        JLXStyleKit.drawBubbleButton(frame: self.bounds)
    }

    override func layoutSubviews() {
        super.layoutSubviews()

        imageView?.frame = CGRect(x: self.bounds.width * 0.5 / 38.0, y: self.bounds.width * 0.5 / 38.0, width: self.bounds.width * 37 / 38.0, height: self.bounds.width * 37 / 38.0)
        imageView?.layer.cornerRadius = bounds.width / 2.0
    }

}

protocol Moveable {
    mutating func moveTo(p: CGPoint)
}

class Car: Moveable {
    func moveTo(p: CGPoint) {
        print("Car move to \(p)")
    }

    func changeOil() {
        print("changeOil")
    }

    var name: String

    init() {
        self.name = ""
    }

    init(name: String) {
        self.name = name
    }

}

struct Shape: Moveable {
    mutating func moveTo(p: CGPoint) {
        print("Shape move to \(p)")
    }

    func draw() {

        print("draw")
    }
}

let prius: Car = Car(name: "A")
let square: Shape = Shape()

var thingToMove: Moveable = prius
thingToMove.moveTo(CGPoint(x: 100, y: 100))
var find: Car = prius
find.name

// 协议可以作为一个类型，来存储实现该协议的变量，但是不能直接调用后者的非协议的方法和属性
//thingToMove.changeOil()
thingToMove = square

let thingsToMove: [Moveable] = [prius, square]

func slide(var slider: Moveable) {
    let positionToSlideTo = CGPoint(x: 88, y: 88)
    slider.moveTo(positionToSlideTo)
}

slide(prius)
slide(square)

protocol Slippery {
    var speed: Double { get }
}

extension Car: Slippery {
    var speed: Double {
        return 1
    }
}

func slipAndSlide(x: protocol<Slippery, Moveable>) {
    print("slipAndSlide")
}
slipAndSlide(prius)

// : Playground - noun: a place where people can play

import UIKit

var fibs = [2, 3, 45, 53, 32, 12, 32, 1, 0, 1]

fibs.map {
    Double($0 * 3)
}

let suits = ["♠", "♥", "♣", "♦"]

let ranks = ["J", "Q", "K", "A"]

let allCombinations = suits.flatMap { suit in
    ranks.map { rank in
        (suit, rank)
    }
}

suits.flatMap { (suit) -> [String]? in
    [suit, suit]
}

suits.flatMap { (suit) -> [String] in
    if suit != "♥" {
        return [suit]
    } else {
        return []
    }
}

fibs.flatMap { (num) in
    print(num)
}

fibs.sort {
    $0 > $1
}

fibs.lexicographicalCompare([3])
fibs.lexicographicalCompare([1])
fibs.lexicographicalCompare([3]) { (num0, num1) -> Bool in
    num0 > num1
}
fibs.lexicographicalCompare([1]) { (num0, num1) -> Bool in
    num0 > num1
}

fibs.reduce(0) { (total, num) -> Int in
    total + num
}

fibs.filter { (num) -> Bool in
    num % 3 == 0
}

fibs.indexOf(4)
fibs.indexOf(1)
fibs.contains(4)
fibs.contains(1)

fibs.minElement()
fibs.minElement { (num0, num1) -> Bool in
    num0 < num1
}
fibs.minElement { (num0, num1) -> Bool in
    num0 > num1
}
fibs.maxElement()
fibs.maxElement { (num0, num1) -> Bool in
    print("num0: \(num0), num1: \(num1)")
    return num0 < num1
}

fibs.maxElement { (num0, num1) -> Bool in
    num0 > num1
}

var strs = ["Lee", "Bee", "Will", "10", ""]
strs.maxElement { (str0, str1) -> Bool in
    str0 < str1
}
strs.maxElement { (str0, str1) -> Bool in
    str0 > str1
}

strs.elementsEqual(["Lee", "Bee", "Will", "10"])
strs.elementsEqual(["Lee", "Bee", "Will", "10", ""])

strs.startsWith(["Lee"])
strs.startsWith(["10"])
strs.startsWith(["Lee"]) { (str0, str1) -> Bool in
    str0 == str1
}

strs.split("10")
strs.split("3")
fibs.split(1)

fibs.split(1, maxSplit: 2, allowEmptySlices: true)
fibs.split(1, maxSplit: 2, allowEmptySlices: false)
fibs.split(1, maxSplit: 3, allowEmptySlices: true)
fibs.split(1, maxSplit: 6, allowEmptySlices: false)
fibs.split(3333, maxSplit: 2, allowEmptySlices: true)
fibs.split(44444, maxSplit: 2, allowEmptySlices: false)

fibs.split(32, maxSplit: 0, allowEmptySlices: true)
fibs.split(32, maxSplit: 1, allowEmptySlices: false)
fibs.split(32, maxSplit: 2, allowEmptySlices: true)
fibs.split(32, maxSplit: 3, allowEmptySlices: false)

fibs.split { (num) -> Bool in
    num % 2 == 0
}

fibs.split(1, allowEmptySlices: true) { (num) -> Bool in
    num % 2 == 1
}

fibs.split(66, allowEmptySlices: true) { (num) -> Bool in
    num % 2 == 1
}

fibs.forEach { (num) in
    print(num - 44)
}

import CoreData

class CoreDataStack {
  
  let modelName = "Dog Walk"
  
  lazy var context: NSManagedObjectContext = {
    
    var managedObjectContext = NSManagedObjectContext(
      concurrencyType: .MainQueueConcurrencyType)
    
    managedObjectContext.persistentStoreCoordinator = self.psc
    return managedObjectContext
    }()
  
  private lazy var psc: NSPersistentStoreCoordinator = {
    
    let coordinator = NSPersistentStoreCoordinator(
      managedObjectModel: self.managedObjectModel)
    
    let url = self.applicationDocumentsDirectory
      .URLByAppendingPathComponent(self.modelName)
    
    do {
      let options =
      [NSMigratePersistentStoresAutomaticallyOption : true]
      
      try coordinator.addPersistentStoreWithType(
        NSSQLiteStoreType, configuration: nil, URL: url,
        options: options)
    } catch  {
      print("Error adding persistent store.")
    }
    
    return coordinator
    }()
  
  private lazy var managedObjectModel: NSManagedObjectModel = {
    
    let modelURL = NSBundle.mainBundle()
      .URLForResource(self.modelName,
        withExtension: "momd")!
    return NSManagedObjectModel(contentsOfURL: modelURL)!
    }()
  
  private lazy var applicationDocumentsDirectory: NSURL = {
    let urls = NSFileManager.defaultManager().URLsForDirectory(
      .DocumentDirectory, inDomains: .UserDomainMask)
    return urls[urls.count-1]
    }()
  
  func saveContext () {
    if context.hasChanges {
      do {
        try context.save()
      } catch let error as NSError {
        print("Error: \(error.localizedDescription)")
        abort()
      }
    }
  }
}

// 1
let privateContext = NSManagedObjectContext(
    concurrencyType: .PrivateQueueConcurrencyType)
privateContext.persistentStoreCoordinator =
    coreDataStack.context.persistentStoreCoordinator

// 2
privateContext.performBlock { () -> Void in
    // 3
    let results: [AnyObject]
    do {
        results = try self.coreDataStack.context
            .executeFetchRequest(self.surfJournalFetchRequest())
    } catch {
        let nserror = error as NSError
        print("ERROR: \(nserror)")
        results = []
    }

    let exportFilePath =
        NSTemporaryDirectory() + "export.csv"
    let exportFileURL = NSURL(fileURLWithPath: exportFilePath)
    NSFileManager.defaultManager().createFileAtPath(
        exportFilePath, contents: NSData(), attributes: nil)

    // 3
    let fileHandle: NSFileHandle?
    do {
        fileHandle = try NSFileHandle(forWritingToURL: exportFileURL)
    } catch {
        let nserror = error as NSError
        print("ERROR: \(nserror)")
        fileHandle = nil
    }

    if let fileHandle = fileHandle {
        // 4
        for object in results {
            let journalEntry = object as! JournalEntry

            fileHandle.seekToEndOfFile()
            let csvData = journalEntry.csv().dataUsingEncoding(
                NSUTF8StringEncoding, allowLossyConversion: false)
            fileHandle.writeData(csvData!)
        }

        // 5
        fileHandle.closeFile()

        // 4
        dispatch_async(dispatch_get_main_queue(), { () -> Void in
            self.navigationItem.leftBarButtonItem =
                self.exportBarButtonItem()
            print("Export Path: \(exportFilePath)")
            self.showExportFinishedAlertView(exportFilePath)
        })
    } else {
        dispatch_async(dispatch_get_main_queue(), { () -> Void in
            self.navigationItem.leftBarButtonItem =
                self.exportBarButtonItem()
        })
    }

} // 5 Closing brace for performBlock()
    

//
//  JLXCameraViewController.swift
//  test AVCam
//
//  Created by Will on 4/15/16.
//  Copyright © 2016 gewill.org. All rights reserved.
//

import UIKit
import Foundation
import AVFoundation
import Photos
import AssetsLibrary

protocol JLXCameraViewControllerDelegate: NSObjectProtocol {
    func cameraViewController(vc: JLXCameraViewController, didFinishCaptureVideoUrl url: NSURL!)
    func cameraViewControllerDidCancel(vc: JLXCameraViewController)
}

enum JLXAVCamSetupResult {
    case Success
    case CameraNotAuthorized
    case SessionConfiguratonFailed
}

private var SessionRunningContext = 0

class JLXCameraViewController: UIViewController, AVCaptureFileOutputRecordingDelegate {
    @IBOutlet var previewView: JLXPreviewView!

    @IBOutlet var cameraUnavailableLabel: UILabel!
    @IBOutlet var resumeButton: UIButton!

    @IBOutlet var flashButton: UIButton!
    @IBOutlet var changeCameraButton: UIButton!
    @IBOutlet var cancelButton: UIButton!

    @IBOutlet var durationLabel: UILabel!

    @IBOutlet var recordButton: UIButton!

    var delegate: JLXCameraViewControllerDelegate?

    // Session management

    // Communicate with the session and other session objects on this queue.
    var sessionQueue = dispatch_queue_create("session queue", DISPATCH_QUEUE_SERIAL)
    dynamic var session: AVCaptureSession!
    var videoDeviceInput: AVCaptureDeviceInput!
    var movieFileOutput: AVCaptureMovieFileOutput!

    // Utilities
    var setupResult: JLXAVCamSetupResult!
    var sessionRunning: Bool!
    var backgroundRecordingId: UIBackgroundTaskIdentifier!
    var durationTimer: NSTimer?
    var seconds: Int!
    var isRecording = false

    // MARK: - life cycle

    override func viewDidLoad() {
        super.viewDidLoad()

        self.setupUI()

        self.setupSession()
    }

    func setupUI() {
        // Disable UI. The UI is enabled if and only if the session starts running.
        self.changeCameraButton.enabled = false
        self.recordButton.enabled = false
        self.flashButton.enabled = false

        self.resumeButton.setTitle("Tap to resume", forState: .Normal)
        self.resumeButton.hidden = true
        self.cameraUnavailableLabel.text = "Camera Unavailable"
        self.cameraUnavailableLabel.hidden = true

        let tapGesture = UITapGestureRecognizer(target: self, action: #selector(JLXCameraViewController.focusAndExposeTap(_:)))
        self.previewView.addGestureRecognizer(tapGesture)
    }

    func setupAuthorization() {
        // Check video authorization status. Video access is required and audio access is optional.
        // If audio access is denied, audio is not recorded during movie recording.

        switch AVCaptureDevice.authorizationStatusForMediaType(AVMediaTypeVideo) {
        case AVAuthorizationStatus.NotDetermined:
            dispatch_suspend(self.sessionQueue)
            AVCaptureDevice.requestAccessForMediaType(AVMediaTypeVideo, completionHandler: { (granted) in
                if granted == false {
                    self.setupResult = JLXAVCamSetupResult.CameraNotAuthorized
                }
                dispatch_resume(self.sessionQueue)
            })
        case AVAuthorizationStatus.Authorized:
            self.setupResult = JLXAVCamSetupResult.Success
        default:
            self.setupResult = JLXAVCamSetupResult.CameraNotAuthorized
        }
    }

    // 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.
    func setupSession() {
        // Create the AVCaptureSession.
        self.session = AVCaptureSession()

        // Setup the preview view.
        self.previewView.setSession(self.session)

        self.setupResult = JLXAVCamSetupResult.Success

        self.setupAuthorization()

        dispatch_async(self.sessionQueue) {
            if self.setupResult != JLXAVCamSetupResult.Success {
                return
            }

            self.backgroundRecordingId = UIBackgroundTaskInvalid

            let videoDevice: AVCaptureDevice = JLXCameraViewController.deviceWithMediaType(AVMediaTypeVideo, preferringPosition: AVCaptureDevicePosition.Back)

            var videoDeviceInput: AVCaptureDeviceInput?
            do {
                videoDeviceInput = try AVCaptureDeviceInput.init(device: videoDevice)
            } catch let error as NSError {
                print("Could not create video device input: \(error.debugDescription)")
            }

            self.session.beginConfiguration()

            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 AAPLPreviewView 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
                    // -[viewWillTransitionToSize:withTransitionCoordinator:].
                    let orientation = AVCaptureVideoOrientation.LandscapeRight
                    let previewLayer = self.previewView.layer as! AVCaptureVideoPreviewLayer
                    previewLayer.connection.videoOrientation = orientation
                }
            } else {
                print("Could not add video device input to the session")
                self.setupResult = JLXAVCamSetupResult.SessionConfiguratonFailed
            }

            // TODO: - test failed
            let audioDevice = AVCaptureDevice.defaultDeviceWithMediaType(AVMediaTypeAudio)
            let audioDeviceInput: AVCaptureDeviceInput?
            do {
                audioDeviceInput = try AVCaptureDeviceInput.init(device: audioDevice)
            } catch let error as NSError {
                print("Could not create audio device input: \(error.debugDescription.debugDescription)")
            }

            let movieFileOutput = AVCaptureMovieFileOutput()
            if self.session.canAddOutput(movieFileOutput) {
                self.session.addOutput(movieFileOutput)
                let connection = movieFileOutput.connectionWithMediaType(AVMediaTypeVideo)
                if #available(iOS 8.0, *) {
                    if connection.supportsVideoStabilization {
                        connection.preferredVideoStabilizationMode = .Auto
                    }
                } else {
                    connection.enablesVideoStabilizationWhenAvailable = true
                }

                if connection.supportsVideoOrientation {
                    connection.videoOrientation = AVCaptureVideoOrientation.LandscapeRight
                }

                self.movieFileOutput = movieFileOutput
            } else {
                print("Could not add movie file output to the session")
                self.setupResult = JLXAVCamSetupResult.SessionConfiguratonFailed
            }

            self.session.commitConfiguration()
        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    override func viewWillAppear(animated: Bool) {
        super.viewWillAppear(animated)

        // response setupResult

        dispatch_async(self.sessionQueue) {
            if let result = self.setupResult {
                switch result {
                case .Success:
                    // Only setup observers and start the session running if setup succeeded.
                    self.addObservers()
                    self.session.startRunning()
                    self.sessionRunning = self.session.running
                case .CameraNotAuthorized:
                    dispatch_async(dispatch_get_main_queue()) {
                        let title = NSBundle.mainBundle().localizedInfoDictionary!["CFBundleName"] as! String
                        let message = String.localizedStringWithFormat("AVCam doesn't have permission to use the camera, please change privacy settings", "Alert message when the user has denied access to the camera")
                        let cancelText = String.localizedStringWithFormat("OK", "Alert OK button")
                        let settingsText = String.localizedStringWithFormat("Settings", "Alert button to open Settings")
                        if #available(iOS 8.0, *) {
                            let alertController = UIAlertController(title: title, message: message, preferredStyle: UIAlertControllerStyle.Alert)
                            let cancelAction = UIAlertAction(title: cancelText, style: UIAlertActionStyle.Cancel, handler: nil)
                            alertController.addAction(cancelAction)
                            let settingsAction = UIAlertAction(title: settingsText, style: UIAlertActionStyle.Default, handler: { (action) in
                                UIApplication.sharedApplication().openURL(NSURL(string: UIApplicationOpenSettingsURLString)!)
                            })
                            alertController.addAction(settingsAction)
                            self.presentViewController(alertController, animated: true, completion: nil)
                        } else {
                            let alert = UIAlertView(title: title, message: message, delegate: nil, cancelButtonTitle: cancelText, otherButtonTitles: settingsText)
                            alert.show()
                        }
                    }
                case .SessionConfiguratonFailed:
                    let title = NSBundle.mainBundle().localizedInfoDictionary!["CFBundleName"] as! String
                    let message = String.localizedStringWithFormat("Unable to capture media", "Alert message when something goes wrong during capture session configuration")
                    let cancelText = String.localizedStringWithFormat("OK", "Alert OK button")
                    if #available(iOS 8.0, *) {
                        let alertController = UIAlertController(title: title, message: message, preferredStyle: UIAlertControllerStyle.Alert)
                        let cancelAction = UIAlertAction(title: cancelText, style: UIAlertActionStyle.Cancel, handler: nil)
                        alertController.addAction(cancelAction)
                        self.presentViewController(alertController, animated: true, completion: nil)
                    } else {
                        let alert = UIAlertView(title: title, message: message, delegate: nil, cancelButtonTitle: cancelText)
                        alert.show()
                    }
                }
            }
        }
    }

    override func viewDidDisappear(animated: Bool) {
        dispatch_async(self.sessionQueue) {
            if self.setupResult == JLXAVCamSetupResult.Success {
                self.session.stopRunning()
                self.removeObservers()
            }
        }

        super.viewDidDisappear(animated)
    }

    // MARK: - Orientation

    override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
        return UIInterfaceOrientationMask.LandscapeRight
    }

    // MARK: - KVO and Notifications

    func addObservers() {
        self.session.addObserver(self, forKeyPath: "running", options: NSKeyValueObservingOptions.New, context: &SessionRunningContext)

        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(subjectAreaDidChange(_:)), name: AVCaptureDeviceSubjectAreaDidChangeNotification, object: self.videoDeviceInput.device)
        // 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(sessionWatInterruptedEnded(_:)), name: AVCaptureSessionWasInterruptedNotification, object: self.session)
        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(sessionWatInterruptedEnded(_:)), name: AVCaptureSessionInterruptionEndedNotification, object: self.session)
    }

    func removeObservers() {
        self.session.removeObserver(self, forKeyPath: "running", context: &SessionRunningContext)

        NSNotificationCenter.defaultCenter().removeObserver(self)
    }

    override func observeValueForKeyPath(keyPath: String?, ofObject object: AnyObject?, change: [String: AnyObject]?, context: UnsafeMutablePointer<Void>) {
        if context == &SessionRunningContext {
            if let isSessionRunning = change?[NSKeyValueChangeNewKey]?.boolValue where
            isSessionRunning == true {
                dispatch_async(dispatch_get_main_queue()) {
                    // Only enable the ability to change camera if the device has more than
                    // one camera.
                    self.changeCameraButton.enabled = isSessionRunning && (AVCaptureDevice.devicesWithMediaType(AVMediaTypeVideo).count > 1)
                    self.recordButton.enabled = isSessionRunning
                }
            }
        } else {
            super.observeValueForKeyPath(keyPath, ofObject: object, change: change, context: context)
        }
    }

    func subjectAreaDidChange(notification: NSNotification) {
        let devicePoiont = CGPoint(x: 0.5, y: 0.5)
        self.focusWithMode(AVCaptureFocusMode.ContinuousAutoFocus, exposureWithMode: AVCaptureExposureMode.ContinuousAutoExposure, atDevicePoint: devicePoiont, monitorSubjectAreaChange: false)
    }

    func sessionRuntimeError(notification: NSNotification) {
        // 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 let error = notification.userInfo?[AVCaptureSessionErrorKey] where
        error.code == AVError.MediaServicesWereReset.rawValue {
            dispatch_async(self.sessionQueue, {
                if self.sessionRunning == true {
                    self.session.startRunning()
                    self.sessionRunning = self.session.running
                } else {
                    dispatch_async(dispatch_get_main_queue(), {
                        self.resumeButton.hidden = false
                    })
                }
            })
        } else {
            self.resumeButton.hidden = false
        }
    }

    func sessionWasInterrupted(notification: NSNotification) {
        // 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:].

        var showResumeButton = false

        // In iOS 9 and later, the userInfo dictionary contains information on why the
        // session was interrupted.
        if #available(iOS 9.0, *) {
            if let reason = notification.userInfo?[AVCaptureSessionInterruptionReasonKey] where reason is Int
            {
                if (reason as! Int) == AVCaptureSessionInterruptionReason.AudioDeviceInUseByAnotherClient.rawValue || (reason as! Int) == AVCaptureSessionInterruptionReason.VideoDeviceInUseByAnotherClient.rawValue {
                    showResumeButton = true
                } else if (reason as! Int) == AVCaptureSessionInterruptionReason.VideoDeviceNotAvailableWithMultipleForegroundApps.rawValue {
                    // Simply fade-in a label to inform the user that the camera is
                    // unavailable.
                    self.cameraUnavailableLabel.hidden = false
                    self.cameraUnavailableLabel.alpha = 0
                    UIView.animateWithDuration(0.25, animations: {
                        self.cameraUnavailableLabel.alpha = 1
                    })
                }
            }
        } else {
            print("Capture session was interrupted")
            showResumeButton = UIApplication.sharedApplication().applicationState == UIApplicationState.Inactive
        }

        if showResumeButton {
            // Simply fade-in a button to enable the user to try to resume the session
            // running.
            self.resumeButton.hidden = false
            self.resumeButton.alpha = 0
            UIView.animateWithDuration(0.25, animations: {
                self.resumeButton.alpha = 1
            })
        }
    }

    func sessionWatInterruptedEnded(notification: NSNotification) {
        print("Capture session interruption ended")

        // hide buttons with animations
        if !self.resumeButton.hidden {
            UIView.animateWithDuration(0.25, animations: {
                self.resumeButton.alpha = 0
                }, completion: { (finished) in
                self.resumeButton.hidden = true
            })
        }

        if !self.cameraUnavailableLabel.hidden {
            UIView.animateWithDuration(0.25, animations: {
                self.cameraUnavailableLabel.alpha = 0
                }, completion: { (finished) in
                self.cameraUnavailableLabel.hidden = true
            })
        }
    }

    // MARK: -  Response Actions

    @IBAction func resumeButtonClick(sender: AnyObject) {
        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.durationTimer = NSTimer(timeInterval: 1.0, target: self, selector: #selector(JLXCameraViewController.refreshDurationLabel), userInfo: nil, repeats: true)
            NSRunLoop.currentRunLoop().addTimer(self.durationTimer!, forMode: NSRunLoopCommonModes)
            self.durationTimer?.fire()

            self.sessionRunning = self.session.running
            if !self.session.running {
                dispatch_async(dispatch_get_main_queue()) {
                    let title = NSBundle.mainBundle().localizedInfoDictionary!["CFBundleName"] as! String
                    let message = String.localizedStringWithFormat("Unable to resume", "Alert message when unable to resume the session running")
                    let cancelText = String.localizedStringWithFormat("OK", "Alert OK button")
                    if #available(iOS 8.0, *) {
                        let alertController = UIAlertController(title: title, message: message, preferredStyle: UIAlertControllerStyle.Alert)
                        let cancelAction = UIAlertAction(title: cancelText, style: UIAlertActionStyle.Cancel, handler: nil)
                        alertController.addAction(cancelAction)
                        self.presentViewController(alertController, animated: true, completion: nil)
                    } else {
                        let alert = UIAlertView(title: title, message: message, delegate: nil, cancelButtonTitle: cancelText)
                        alert.show()
                    }
                }
            } else {
                dispatch_async(dispatch_get_main_queue()) {
                    self.resumeButton.hidden = false
                }
            }
        }
    }
    @IBAction func recordButtonClick(sender: AnyObject) {
        // Disable the Camera button until recording finishes, and disable the Record
        // button until recording starts or finishes. See the
        // AVCaptureFileOutputRecordingDelegate methods.
        self.changeCameraButton.enabled = false
        self.recordButton.enabled = false

        if self.isRecording == true {
            self.durationTimer?.invalidate()
            self.durationTimer = nil
            self.seconds = 0
            self.durationLabel.text = secondsToFormatTimeFull(0)
        } else {
            self.seconds = 0
            self.durationTimer = NSTimer(timeInterval: 1.0, target: self, selector: #selector(JLXCameraViewController.refreshDurationLabel), userInfo: nil, repeats: true)
            NSRunLoop.currentRunLoop().addTimer(self.durationTimer!, forMode: NSRunLoopCommonModes)
            self.durationTimer?.fire()
        }

        self.isRecording = !isRecording

        dispatch_async(self.sessionQueue) {
            if !self.movieFileOutput.recording && UIDevice.currentDevice().multitaskingSupported {
                // 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)

                // Turn OFF flash for video recording.
                JLXCameraViewController.setFlashMode(AVCaptureFlashMode.Off, forDevice: self.videoDeviceInput.device)

                // Start recording to a temporary file.
                let outputFileName = NSProcessInfo.processInfo().globallyUniqueString
                let outputFileUrl = NSURL(fileURLWithPath: NSTemporaryDirectory()).URLByAppendingPathComponent(outputFileName).URLByAppendingPathExtension("mov")
                self.movieFileOutput.startRecordingToOutputFileURL(outputFileUrl, recordingDelegate: self)
            } else {
                self.movieFileOutput.stopRecording()
            }
        }
    }

    @IBAction func changeCameraButtonClick(sender: AnyObject) {
        self.changeCameraButton.enabled = false
        self.recordButton.enabled = false

        dispatch_async(self.sessionQueue) {
            let currentVideoDivice = self.videoDeviceInput.device
            var preferredPosition = AVCaptureDevicePosition.Unspecified
            let currentPosition = currentVideoDivice.position

            switch currentPosition {
            case AVCaptureDevicePosition.Front:
                preferredPosition = AVCaptureDevicePosition.Back
            case AVCaptureDevicePosition.Back:
                preferredPosition = AVCaptureDevicePosition.Front
            default:
                break
            }

            let videoDevice = JLXCameraViewController.deviceWithMediaType(AVMediaTypeVideo, preferringPosition: preferredPosition)

            var videoDeviceInput: AVCaptureDeviceInput?
            do {
                videoDeviceInput = try AVCaptureDeviceInput.init(device: videoDevice)
            } catch let error as NSError {
                print("Could not create video device input: \(error.debugDescription)")
            }

            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: currentVideoDivice)

                JLXCameraViewController.setFlashMode(AVCaptureFlashMode.Auto, forDevice: videoDevice)
                NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(JLXCameraViewController.subjectAreaDidChange(_:)), name: AVCaptureDeviceSubjectAreaDidChangeNotification, object: videoDevice)

                self.session.addInput(videoDeviceInput)
                self.videoDeviceInput = videoDeviceInput
            } else {
                self.session.addInput(self.videoDeviceInput)
            }

            let connection = self.movieFileOutput.connectionWithMediaType(AVMediaTypeVideo)
            if connection.supportsVideoStabilization {
                if #available(iOS 8.0, *) {
                    connection.preferredVideoStabilizationMode = .Auto
                } else {
                    connection.enablesVideoStabilizationWhenAvailable = true
                }
            }

            self.session.commitConfiguration()

            dispatch_async(dispatch_get_main_queue()) {
                self.changeCameraButton.enabled = true
                self.recordButton.enabled = true
            }
        }
    }

    func focusAndExposeTap(gestureRecognizer: UIGestureRecognizer) {
        let devicePoint = (self.previewView.layer as! AVCaptureVideoPreviewLayer).captureDevicePointOfInterestForPoint(gestureRecognizer.locationInView(gestureRecognizer.view))
        self.focusWithMode(AVCaptureFocusMode.AutoFocus, exposureWithMode: AVCaptureExposureMode.AutoExpose, atDevicePoint: devicePoint, monitorSubjectAreaChange: true)
    }

    @IBAction func flashButtonClick(sender: AnyObject) {
        // TODO: - should deal while changeCameraButton
    }

    func refreshDurationLabel() {
        seconds = seconds + 1
        self.durationLabel.text = secondsToFormatTimeFull(Double(self.seconds))
    }

    @IBAction func cancelButtonClick(sender: AnyObject) {
        delegate?.cameraViewControllerDidCancel(self)
        self.dismissViewControllerAnimated(true, completion: nil)
    }

    // MARK: - File Output Recording Delegate
    func captureOutput(captureOutput: AVCaptureFileOutput!, didStartRecordingToOutputFileAtURL fileURL: NSURL!, fromConnections connections: [AnyObject]!) {
        // Enable the Record button to let the user stop the recording.
        dispatch_async(dispatch_get_main_queue()) {
            self.recordButton.enabled = true
            self.recordButton.setTitle(String.localizedStringWithFormat("Stop", "Recording button stop title"), forState: .Normal)
        }
    }

    func captureOutput(captureOutput: AVCaptureFileOutput!, didFinishRecordingToOutputFileAtURL outputFileURL: NSURL!, fromConnections connections: [AnyObject]!, error: NSError!) {
        // 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 isRecording
        // 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.

        self.delegate?.cameraViewController(self, didFinishCaptureVideoUrl: outputFileURL)
        self.dismissViewControllerAnimated(true, completion: nil)
    }

    // MARK: - Device Configuration
    func focusWithMode(focusMode: AVCaptureFocusMode, exposureWithMode exposureMode: AVCaptureExposureMode, atDevicePoint point: CGPoint, monitorSubjectAreaChange: Bool) {
        dispatch_async(self.sessionQueue) {
            let device = self.videoDeviceInput.device
            do {
                try device.lockForConfiguration()
                // 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.focusPointOfInterestSupported && device.isFocusModeSupported(AVCaptureFocusMode.AutoFocus) {
                    device.focusPointOfInterest = point
                    device.focusMode = focusMode
                }

                if device.exposurePointOfInterestSupported && device.isExposureModeSupported(AVCaptureExposureMode.AutoExpose) {
                    device.exposurePointOfInterest = point
                    device.exposureMode = exposureMode
                }

                device.subjectAreaChangeMonitoringEnabled = monitorSubjectAreaChange

                device.unlockForConfiguration()
            } catch let error as NSError {
                print(" \(error.debugDescription)")
            }
        }
    }

    class func setFlashMode(flashMode: AVCaptureFlashMode, forDevice device: AVCaptureDevice) {
        if device.hasFlash && device.isFlashModeSupported(flashMode) {
            do {
                try device.lockForConfiguration()
                device.flashMode = flashMode
                device.unlockForConfiguration()
            } catch let error as NSError {
                print("Could not lock device for configuration: \(error.debugDescription)")
            }
        }
    }

    class func deviceWithMediaType(mediaType: String, preferringPosition position: AVCaptureDevicePosition) -> AVCaptureDevice {
        let devices = AVCaptureDevice.devicesWithMediaType(mediaType) as![AVCaptureDevice!]
        var captureDevice = devices.first

        for device in devices {
            if device.position == position {
                captureDevice = device
                break
            }
        }

        return captureDevice!
    }
}