let queue = OperationQueue()
var bgTaskId = UIBackgroundTaskInvalid
bgTaskId = UIApplication.shared.beginBackgroundTask { () -> Void in
    bgTaskId = UIBackgroundTaskInvalid
}
queue.addOperation(BlockOperation(block: { () -> Void in
    //do something in the background
    UIApplication.shared.endBackgroundTask(bgTaskId)
}))

inTheBackground {
    //move to the background and get on with your life
}

DispatchQueue.main.async {
    //do something on the main thread
}

onTheMainThread {
    //you're back to the main thread
}

DispatchQueue.global().async {
//do something in the global queue
}

inTheGlobalQueue {
//you're back in the global queue
}

var sequentialOperations = [Operation]()
sequentialOperations.append(AsyncOperation({ (op) in
    print("Executing sequential operation 1")
    op.finish()
}))
sequentialOperations.append(BlockOperation({ 
    print("Executing sequential operation 2")
    //The sequential operations work with any Operation objects, not just AsyncOperations
}))
sequentialOperations.append(BlockOperation({ (op) in
    print("Executing sequential operation 3")
    op.finish()
}))
OperationQueue.background.addSequentialOperations(sequentialOperations, waitUntilFinished: false)

OperationQueue.background.addOperation {
    //do something
}

self.loadThingsFromTheInternet(callback: { (result, error) in
    //process the result
})

operationQueue.addOperation(BlockOperation({
    //We're on a background thread now; NICE!
    self.loadThingsFromTheInternet(callback: { (result, error) in
        //process the result
        //god knows in which thread this function returns... 
        //BTW, where's the BlockOperation?
    })
    //But wait... As soon as we call this function, the operation will already be finished and removed from the queue
    //We haven't finished what we wanted to do!
    //And the queue will now start executing its next operation!
}))

operationQueue.addOperation(AsyncOperation({ (op) in
    //We're on a background thread now; NICE!
    self.loadThingsFromTheInternet(callback: { (result, error) in
        //process the result
        //then move to the main thread
        onTheMainThread {
            //go to the main thread
            inTheBackground {
                //do more stuff in the background again
                //once everything is done, finish
                op.finish()
                //only now the queue will start working on the next thing
            }
        }
    })
}))

class ViewController: UIViewController {

    deinit {
        NotificationCenter.default.removeObserver(self)
    }
        
    override func viewDidLoad() {
        super.viewDidLoad()
        
        NotificationCenter.default.addObserver(self, selector: #selector(handleBackgroundNotification(_:)), name: .UIApplicationWillResignActiveNotification, object: nil)
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        
        /*
            do something when the view appears,
            but wait...
        */
    }
        
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
            
        /*
            do something when the view disappears,
            but wait...
        */
    }
        
    func handleBackgroundNotification(_ notification: Notification) {
        /*
            say the user presses the home button
            now that viewWillDisappear method will never be called and you won't be able to undo the things you wanted...
        */
    }
}

class ViewController: UIViewController, Visibility {

    open func willChangeVisibility() {
        //NO NEED TO CALL SUPER!
            
        if !self.isVisible { //we're becoming visible, either from navigation or from the app being launched
            // \o/
        } else { //we're becoming invisible
            
        }
    }
        
    open func didChangeVisibility() {
        if self.isVisible { //we're visible
            // \o/
        } else { //we're invisible
            
        }
    }
}

deinit {
    self.resignAppStatesHandler()
}

//Visibility
var appStateNotifications: [NSObjectProtocol] = []

public var visible = false

open func willChangeVisibility() {

}

open func didChangeVisibility() {

}

//View Controller Life Cycle
override open func viewDidLoad()
{
    super.viewDidLoad()

    self.becomeAppStatesHandler()
}

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

    self.willChangeVisibility()
    self.isVisible = true
}

override open func viewDidAppear(_ animated: Bool)
{
    super.viewDidAppear(animated)

    self.didChangeVisibility()
}

override open func viewWillDisappear(_ animated: Bool)
{
    self.willChangeVisibility()
    self.isVisible = false

    super.viewWillDisappear(animated)
}

override open func viewDidDisappear(_ animated: Bool)
{
    self.didChangeVisibility()

    super.viewDidDisappear(animated)
}