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 var isSyncInProgress = false
    private var syncAdapter = SyncAdapter()
    private let gcmMessageIDKey = "gcm.message_id"
    private var appData = AppData.sharedInstance


    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 {

        let database = Database.sharedInstance
        if database.open() != nil {
              database.createTables()
        }
        
        if let new_uuid = UIDevice.current.identifierForVendor?.uuidString {
           
            let old_uuid = appData.deviceUuid
            if new_uuid != old_uuid {
                var sync = SyncModel()
                sync.type = Constants.SYNC_ADAPTER_TYPE_DEVICE
                sync.data = new_uuid
                
                if SyncDao.sharedInstance.insert(record: sync) > 0 {
                    appData.deviceUuid = new_uuid
                    appData.save()
                    
                    syncAdapter.sync {
                            success in
                    }
                }
            }

        }
              
  
        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
    }
    
    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 { 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("token: ", token)
        

        if appData.fcmToken != token  {
            
            var sync = SyncModel()
            sync.data = token
            sync.type = Constants.SYNC_ADAPTER_TYPE_FCM
            
            if SyncDao.sharedInstance.insert(record: sync) > 0 {
            
                appData.fcmToken = token
                appData.save()
                
                syncAdapter.sync {
                        success in
                }
            }
        }
    }
}

@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)
           

           if appData.fcmToken != token  {
               
               var sync = SyncModel()
               sync.data = token
               sync.type = Constants.SYNC_ADAPTER_TYPE_FCM
               
               if SyncDao.sharedInstance.insert(record: sync) > 0 {
               
                   appData.fcmToken = token
                   appData.save()
                   
                   syncAdapter.sync {
                           success in
                   }
               }
           }
    }
    
    

    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()
  }
}