NexilisLibraryiOS/AppBuilder/AppBuilder/SceneDelegate.swift

//
//  SceneDelegate.swift
//  TestQmeraLite
//
//  Created by Qindi on 29/11/21.
//

import UIKit
import NexilisLite

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?
    var splashWindow: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
        guard let _ = (scene as? UIWindowScene) else { return }
        if let launchStoryboardName = InfoPList.launchStoryboardName,
                   let windowScene          = self.window?.windowScene
        {
            splashWindow = splashWindow ??
            {
                let window = UIWindow(windowScene: windowScene)
                    window.windowLevel = .statusBar

                let storyboard = UIStoryboard(name: launchStoryboardName, bundle: nil)

                window.rootViewController = storyboard.instantiateInitialViewController()
                window.isHidden           = false

                // ⏳Wait for 5 seconds, then remove.
                //
                DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(1))
                {
                    UIView.animate(withDuration: -1, // system default
                        animations:
                        {
                            self.splashWindow?.alpha = 0
                        },
                        completion:
                        { _ in
                            self.splashWindow?.isHidden = true
                            self.splashWindow = nil
                        }
                    )
                }
                
                let tabBarAppearance: UITabBarAppearance = UITabBarAppearance()
                tabBarAppearance.configureWithTransparentBackground()
                if let rootViewController = window.rootViewController {
                    // Check if dark mode is enabled
                    let isDarkMode = rootViewController.traitCollection.userInterfaceStyle == .dark
                    if isDarkMode {
                        tabBarAppearance.backgroundColor = .black.withAlphaComponent(0.7)
                    } else {
                        tabBarAppearance.backgroundColor = .white.withAlphaComponent(0.9)
                    }
                    if Utils.getReverseTab() == "1" {
                        tabBarAppearance.backgroundColor = .black.withAlphaComponent(0.7)
                    }
                }
                if #available(iOS 13.0, *) {
                    UITabBar.appearance().standardAppearance = tabBarAppearance
                }
                if #available(iOS 15.0, *) {
                    UITabBar.appearance().scrollEdgeAppearance = tabBarAppearance
                }

                return window
            }()
        }
    }

    func sceneDidDisconnect(_ scene: UIScene) {
        // Called as the scene is being released by the system.
        // This occurs shortly after the scene enters the background, or when its session is discarded.
        // Release any resources associated with this scene that can be re-created the next time the scene connects.
        // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead).
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
        APIS.enterForeground()
    }

    func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state.
        APIS.enterBackground()
    }


}

struct InfoPList
{
    private static func value(for name: String) -> String? { Bundle.main.object(forInfoDictionaryKey: name) as? String }

    static var bundleIdentifier:         String? { self.value(for: "CFBundleIdentifier") }
    static var bundleDisplayName:        String? { self.value(for: "CFBundleDisplayName") }
    static var bundleShortVersionString: String? { self.value(for: "CFBundleShortVersionString") }
    static var bundleVersion:            String? { self.value(for: "CFBundleVersion") }

    static var launchStoryboardName: String? { self.value(for: "UILaunchStoryboardName") }
    static var mainStoryboardName:   String? { self.value(for: "UIMainStoryboardFile") }
}