trifork / triforkswiftextensions Goto Github PK

presentOkAlert

//
//  GlobalDialog.swift
//  Created by Kasper Tvede on 18/02/2019.
//  Copyright © 2019 Trifork a/s. All rights reserved.
//

// inspiration drawn from https://github.com/agilityvision/FFGlobalAlertController
//  && https://github.com/lostatseajoshua/Alerts/blob/master/Alerts/AlertCoordinator.swift
// and further see https://stackoverflow.com/a/25428409
import Foundation
import UIKit

// Declare a global var to produce a unique address as the assoc object handle for the alert window variable
private var alertWindowObjectHandle: UInt8 = 0
// Declare a global var to produce a unique address as the assoc object handle for the dialog id variable
private var dialogIdObjectHandle: UInt8 = 1


//static variables for functionality; kept private as this is quite edgy already.
private var numOfGlobalDialogsShowing: Int = 0

private var dialogIdSet: Set<Int> = Set()


// MARK: - 
extension UIAlertController {
    
    /// This creates a property on a ui alert controller via objective C.
    private var alertWindow: UIWindow? {
        get {
            return objc_getAssociatedObject(self, &alertWindowObjectHandle) as? UIWindow
        }
        set {
            objc_setAssociatedObject(self, &alertWindowObjectHandle, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
    /// This creates a property on a ui alert controller via objective C.
    private var dialogId: Int? {
        get {
            return objc_getAssociatedObject(self, &dialogIdObjectHandle) as? Int
        }
        set {
            objc_setAssociatedObject(self, &dialogIdObjectHandle, newValue, objc_AssociationPolicy.OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
    
    //can safely be called from any thread, and anywhere. multiple calls will just stack up.
    func showGlobally(animated: Bool = true) {
        DispatchQueue.main.async {
            numOfGlobalDialogsShowing += 1
            let window = UIWindow(frame: UIScreen.main.bounds)
            let rootController = UIViewController()
            window.rootViewController = rootController
            //above all else
            window.windowLevel = UIWindow.Level.alert + 1
            self.alertWindow = window
            window.makeKeyAndVisible()
            rootController.present(self, animated: animated)
        }
    }
    
    
    /// Only shows the igen dialog iff there are no global dialogs there already.
    ///
    /// - Parameter animated: true if the dialog should be animated in place
    func showGloballyIfNoGlobalIsPresented(animated: Bool = true) {
        if numOfGlobalDialogsShowing > 0 {
            return
        }
        showGlobally(animated: animated)
    }
    
    /// a more advanced editon; where we simply map each dialog to a given id, and iff that id is presented then skips displaying it (akk preventing dual
    ///   displaing these dialogs).
    ///
    /// - Parameters:
    ///   - id: the unique id, (so if mulitple dialogs contain this, then only the first one will be shown, prevents displaying multiple dialogs)
    ///   - animated: whenever the appearence should be animated
    func showGloballyWithId(id: Int, animated: Bool = true) {
        //force it though the main thread, thus ensuring no data raceing, since 1 thing can at max execute at the mainthread.
        DispatchQueue.main.async {
            if dialogIdSet.contains(id) {
                return
            }
            dialogIdSet.insert(id)
            self.dialogId = id
            self.showGlobally(animated: animated)
        }
    }
    //clean up when the dialog gets closed.
    override open func viewDidDisappear(_ animated: Bool) {
        super.viewDidAppear(animated)
        //cleanup
        numOfGlobalDialogsShowing -= 1
        if let id = dialogId {
            dialogIdSet.remove(id)
        }
        //dismiss all visible things.
        alertWindow?.isHidden = true
        //and make it possible to garbage collect
        alertWindow = nil
    }
    
    
}