Proyectos de Subversion Iphone Microlearning - Inconcert

//

//  AppDelegate.swift

//  twogetskills

//

//  Created by Efrain Yanez Recanatini on 2/23/22.

//

import Foundation

import Firebase

import Messages

import BackgroundTasks

//UIResponder, UIApplicationDelegate {

class AppDelegate : NSObject, UIApplicationDelegate {

    private let database = Database.sharedInstance

    private let gcmMessageIDKey = "gcm.message_id"

    private var appData = AppData.sharedInstance

    private var syncAdapter = SyncAdapter()

    private var isSyncInProgress = false

    private static var orientationLock = UIInterfaceOrientationMask.portrait

    func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {

        return AppDelegate.orientationLock

    }

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions:

        [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

        database.open()

        database.createTables()

        database.close()

        print("observador del UUID del dispositivo")

        NotificationCenter.default.addObserver(self, selector: #selector(receivingNewDevice(n:)), name: .receivingNewDevice, object: nil)

        print("observador del FCM TOKEN")

        NotificationCenter.default.addObserver(self, selector: #selector(receivingNewToken(n:)), name: .receivingNewToken, object: nil)

        if let new_uuid = UIDevice.current.identifierForVendor?.uuidString {

            let userInfo = ["uuid": new_uuid]

            NotificationCenter.default.post(name: .receivingNewDevice , object: self, userInfo: userInfo)

        }

        FirebaseApp.configure()

        Messaging.messaging().delegate = self

        if #available(iOS 10.0, *) {

            // For iOS 10 display notification (sent via APNS)

            UNUserNotificationCenter.current().delegate = self

            let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]

            UNUserNotificationCenter.current().requestAuthorization(

                options: authOptions,

                completionHandler: {_, _ in })

        } else {

            let settings: UIUserNotificationSettings =

                UIUserNotificationSettings(types: [.alert, .badge, .sound], categories: nil)

            application.registerUserNotificationSettings(settings)

        }

        application.registerForRemoteNotifications()

        registerBGTasksScheduler()

        scheduleProcess()

        scheduleRefresh()

        return true

    }

    // Storage of the UID once the notification is received

       @objc func receivingNewDevice(n: NSNotification){

            print("receivingNewDevice")

            if n.userInfo != nil{

                if let new_uuid = n.userInfo?["uuid"]! as? String {

                    let old_uuid = appData.deviceUuid

                    if new_uuid != old_uuid {

                        db = database.open()

                        if db != nil {

                            var sync = SyncModel()

                            sync.type = Constants.SYNC_ADAPTER_TYPE_DEVICE

                            sync.data = new_uuid

                            let syncDao = SyncDao(db : db)

                            if syncDao.insert(record: sync) > 0 {

                                appData.deviceUuid = new_uuid

                                appData.save()

                                syncAdapter.sync {

                                        success in

                                }

                            }

                        }

                        database.close()

                    }

                }

            }

        }

        @objc func receivingNewToken(n: NSNotification){

            if n.userInfo != nil{

                if let token = n.userInfo?["token"]! as? String {

                    if !token.isEmpty {

                        if appData.fcmToken != token  {

                            var db = database.open()

                            if db != nil {

                                var sync = SyncModel()

                                sync.data = token

                                sync.type = Constants.SYNC_ADAPTER_TYPE_FCM

                                let syncDao = SyncDao(db: db)

                                if syncDao.insert(record: sync) > 0 {

                                    appData.fcmToken = token

                                    appData.save()

                                    syncAdapter.sync {

                                            success in

                                    }

                                }

                            }

                            database.close()

                        }

                   }

               }

           }

        }

    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any],

                         fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {

        if let messageID = userInfo[gcmMessageIDKey] {

            print("Message ID: \(messageID)")

        }

        processNotification(userInfo: userInfo, isForeground: false)

        completionHandler(UIBackgroundFetchResult.newData)

    }

    func registerBGTasksScheduler() {

        BGTaskScheduler.shared.register(forTaskWithIdentifier: Constants.BACKGROUND_TASK_REFRESH, using: nil) { task in

                 self.handleRefreshTask(task: task as! BGAppRefreshTask)

        }

        BGTaskScheduler.shared.register(forTaskWithIdentifier: Constants.BACKGROUND_TASK_PROCESS, using: nil) { task in

                 self.handleProcessTask(task: task as! BGProcessingTask)

        }

    }

    func scheduleRefresh() {

        let request = BGAppRefreshTaskRequest(identifier: Constants.BACKGROUND_TASK_REFRESH)

        request.earliestBeginDate = Date(timeIntervalSinceNow: 10 * 60)

        do {

             try BGTaskScheduler.shared.submit(request)

        } catch {

            print("Could not schedule app refresh: \(error)")

        }

    }

    func scheduleProcess() {

        let request = BGProcessingTaskRequest(identifier: Constants.BACKGROUND_TASK_PROCESS)

        request.earliestBeginDate = Date(timeIntervalSinceNow: 10 * 60)

        request.requiresNetworkConnectivity = true

        request.requiresExternalPower = false

        do {

            try BGTaskScheduler.shared.submit(request)

        } catch {

            print("Could not schedule processing: \(error)")

        }

    }

    func handleProcessTask(task: BGProcessingTask) {

        scheduleProcess()

        let syncAdapter = SyncAdapter()

        syncAdapter.sync(isForeground: false) { success in

            task.setTaskCompleted(success: success)

        }

        task.setTaskCompleted(success: true)

    }

    func handleRefreshTask(task: BGAppRefreshTask) {

        scheduleRefresh()

        let syncAdapter = SyncAdapter()

        if syncAdapter.isCheckChangesRequired() {

            syncAdapter.checkChanges(isForeground: false) { success in

                task.setTaskCompleted(success: success)

            }

        } else {

            task.expirationHandler = {

                task.setTaskCompleted(success: false)

             }

        }

        task.setTaskCompleted(success: true)

    }

}

extension AppDelegate: MessagingDelegate {

    func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {

        let token = fcmToken ?? ""

        print( "MessagingDelegate didReceiveRegistrationToken: \(token)")

        let userInfo = ["token": token]

           NotificationCenter.default.post(name: .receivingNewToken , object: self, userInfo: userInfo)

    }

}

@available(iOS 10, *)

extension AppDelegate : UNUserNotificationCenterDelegate {

  // Receive displayed notifications for iOS 10 devices.

  func userNotificationCenter(_ center: UNUserNotificationCenter,

                              willPresent notification: UNNotification,

    withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {

    let userInfo = notification.request.content.userInfo

    if let messageID = userInfo[gcmMessageIDKey] {

        print("Message ID: \(messageID)")

    }

    processNotification(userInfo: userInfo, isForeground: true)

    completionHandler([[.banner, .badge, .sound]])

  }

    private func processNotification(userInfo : [AnyHashable : Any], isForeground : Bool) {

        let now = Date()

        let dateFormatter = DateFormatter()

        dateFormatter.dateFormat = Constants.FORMAT_DATE_YMD

        let timeFormatter = DateFormatter()

        timeFormatter.dateFormat = Constants.FORMAT_TIME_12

        guard let apsDict = userInfo["aps"]as?[String:Any] else {return}

        guard let alertDict = apsDict["alert"]as?[String:Any]else {return}

        let title = alertDict["title"]  as? String ?? ""

        let body = alertDict["body"]  as? String ?? ""

        let url = userInfo.index(forKey: "url")  == nil ?  "" : userInfo["url"] as? String ?? ""

        let command = userInfo.index(forKey: "command") == nil ? "" : userInfo["command"] as? String ?? ""

        let newCapsules = userInfo.index(forKey: "new_capsules") == nil ? 0 : Int(userInfo["new_capsules"] as? String ?? "") ?? 0

        if command == "signout" {

            NotificationCenter.default.post(name: Constants.NOTIFICATION_NAME_COMMAND_EXIT , object: self, userInfo: nil)

        }

        else if command == "content-refresh" {

            let userinfo = [

                "title" : title,

                "body" : body,

                "new_capsules" : String(newCapsules),

                "is_foreground" : (isForeground ? "1" : "0")

            ]

            NotificationCenter.default.post(name: Constants.NOTIFICATION_NAME_COMMAND_REFRESH_CONTENT , object: self, userInfo: userinfo)

        } else {

            let userinfo = [

                "title" : title,

                "body" : body,

                "url" : url,

            ]

            NotificationCenter.default.post(name: Constants.NOTIFICATION_NAME_PUSH , object: self, userInfo: userInfo)

        }

    }

    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {

        print( "didRegisterForRemoteNotificationsWithDeviceToken")

        let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }

        let token = tokenParts.joined()

            print("token: ", token)

        let userInfo = ["token": token]

        NotificationCenter.default.post(name: .receivingNewToken , object: self, userInfo: userInfo)

    }

    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {

        print( "didFailToRegisterForRemoteNotificationsWithError")

    }

  func userNotificationCenter(_ center: UNUserNotificationCenter,

                              didReceive response: UNNotificationResponse,

                              withCompletionHandler completionHandler: @escaping () -> Void) {

    let userInfo = response.notification.request.content.userInfo

    if let messageID = userInfo[gcmMessageIDKey] {

      print("Message ID from userNotificationCenter didReceive: \(messageID)")

    }

    processNotification(userInfo: userInfo, isForeground: true)

    completionHandler()

  }

}