@applicaster/quick-brick-native-apple 5.16.0 → 5.16.1

package/apple/QuickBrickApple.podspec.json

@@ -1,6 +1,6 @@
 {
   "name": "QuickBrickApple",
-  "version": "5.16.0",
+  "version": "5.16.1",
   "platforms": {
     "ios": "14.0",
     "tvos": "14.0"
@@ -16,7 +16,7 @@
   "authors": "Applicaster LTD.",
   "source": {
     "git": "https://github.com/applicaster/Zapp-Frameworks.git",
-    "tag": "@@applicaster/quick-brick-native-apple/5.16.0"
+    "tag": "@@applicaster/quick-brick-native-apple/5.16.1"
   },
   "requires_arc": true,
   "source_files": "universal/**/*.{m,swift}",

package/apple/ios/LocalNotifications/ReactNativeManager+UNUserNotificationCenterDelegate.swift

@@ -10,15 +10,17 @@ import React
 import ZappCore
 
 extension ReactNativeManager: UNUserNotificationCenterDelegate {
-    public func userNotificationCenter(_ center: UNUserNotificationCenter,
-                                       willPresent notification: UNNotification,
-                                       withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+    public func userNotificationCenter(_: UNUserNotificationCenter,
+                                       willPresent _: UNNotification,
+                                       withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void)
+    {
         completionHandler([.alert, .sound])
     }
 
-    public func userNotificationCenter(_ center: UNUserNotificationCenter,
+    public func userNotificationCenter(_: UNUserNotificationCenter,
                                        didReceive response: UNNotificationResponse,
-                                       withCompletionHandler completionHandler: @escaping () -> Void) {
+                                       withCompletionHandler completionHandler: @escaping () -> Void)
+    {
         guard let url = LocalNotificationResponseParser.urlFromLocalNotification(response: response) else {
             completionHandler()
             return

package/apple/ios/ReactNative/PushBridge.swift

@@ -16,16 +16,16 @@ class PushBridge: NSObject, RCTBridgeModule {
     let getTagsErrorCode = "error_get_tags"
 
     static func moduleName() -> String! {
-        return "PushBridge"
+        "PushBridge"
     }
 
     public class func requiresMainQueueSetup() -> Bool {
-        return true
+        true
     }
 
     /// prefered thread on which to run this native module
     @objc public var methodQueue: DispatchQueue {
-        return DispatchQueue.main
+        DispatchQueue.main
     }
 
     /// Subscribe the push provider with the tags passed as parameters
@@ -36,17 +36,16 @@ class PushBridge: NSObject, RCTBridgeModule {
     ///   - rejecter: rejecter when something fails
     @objc func registerTags(_ tags: [String]?,
                             resolver: @escaping RCTPromiseResolveBlock,
-                            rejecter: @escaping RCTPromiseRejectBlock) {
-        
+                            rejecter: @escaping RCTPromiseRejectBlock)
+    {
         FacadeConnector.connector?.push?.addTags(tags, completion: { result in
             switch result {
-            case .success(_):
+            case .success:
                 resolver(true)
             case let .failure(error):
                 rejecter(self.addTagsErrorCode, error.description, nil)
             }
         })
-
     }
 
     /// Remove the tags from the push provider
@@ -57,11 +56,11 @@ class PushBridge: NSObject, RCTBridgeModule {
     ///   - rejecter: rejecter when something fails
     @objc func unregisterTags(_ tags: [String]?,
                               resolver: @escaping RCTPromiseResolveBlock,
-                              rejecter: @escaping RCTPromiseRejectBlock) {
-
+                              rejecter: @escaping RCTPromiseRejectBlock)
+    {
         FacadeConnector.connector?.push?.removeTags(tags, completion: { result in
             switch result {
-            case .success(_):
+            case .success:
                 resolver(true)
             case let .failure(error):
                 rejecter(self.removeTagsErrorCode, error.localizedDescription, nil)
@@ -74,7 +73,8 @@ class PushBridge: NSObject, RCTBridgeModule {
     /// - Parameters:
     ///   - resolver: resolver when everything succeed
     @objc func getRegisteredTags(_ resolver: @escaping RCTPromiseResolveBlock,
-                                 rejecter: @escaping RCTPromiseResolveBlock) {
+                                 rejecter _: @escaping RCTPromiseResolveBlock)
+    {
         let tags = FacadeConnector.connector?.push?.getDeviceTags()
         resolver(tags)
     }

package/apple/ios/ReactNative/QuickBrickExceptionManager.swift

@@ -16,43 +16,45 @@ class QuickBrickExceptionManager: RCTExceptionsManager, RCTExceptionsManagerDele
 
     func handleSoftJSException(withMessage message: String?, stack: [Any]?, exceptionId: NSNumber) {
         guard let message = message,
-                let stack = stack else {
+              let stack = stack
+        else {
             return
         }
 
         let logOrigin = OSLog(subsystem: "\(Self.self)", category: "handleSoftJSException")
         os_log("handleSoftJSException message: %{public}@, stack: %{public}@",
-                log: logOrigin,
-                type: .error,
-                message, stack)
+               log: logOrigin,
+               type: .error,
+               message, stack)
 
         logger?.errorLog(message: ReactNativeManagerLogs.handleSoftJSException.message,
-                            category: ReactNativeManagerLogs.handleSoftJSException.category,
-                            data: [
-                                "message": message,
-                                "stack": stack,
-                                "exceptionId": "\(exceptionId)",
-                            ])
+                         category: ReactNativeManagerLogs.handleSoftJSException.category,
+                         data: [
+                             "message": message,
+                             "stack": stack,
+                             "exceptionId": "\(exceptionId)",
+                         ])
     }
 
     func handleFatalJSException(withMessage message: String?, stack: [Any]?, exceptionId: NSNumber) {
         guard let message = message,
-                let stack = stack else {
+              let stack = stack
+        else {
             return
         }
 
         let logOrigin = OSLog(subsystem: "\(Self.self)", category: "handleFatalJSException")
         os_log("handleFatalJSException message: %{public}@, stack: %{public}@",
-                log: logOrigin,
-                type: .error,
-                message, stack)
+               log: logOrigin,
+               type: .error,
+               message, stack)
 
         logger?.errorLog(message: ReactNativeManagerLogs.handleFatalJSException.message,
-                            category: ReactNativeManagerLogs.handleFatalJSException.category,
-                            data: [
-                                "message": message,
-                                "stack": stack,
-                                "exceptionId": "\(exceptionId)",
-                            ])
+                         category: ReactNativeManagerLogs.handleFatalJSException.category,
+                         data: [
+                             "message": message,
+                             "stack": stack,
+                             "exceptionId": "\(exceptionId)",
+                         ])
     }
 }

package/apple/ios/ReactNative/QuickBrickViewController.swift

@@ -17,17 +17,17 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
     }
 
     lazy var logger = Logger.getLogger(for: QuickBrickViewControllerLogs.subsystem)
-    var currentOrientation = UIDevice.current.orientation;
+    var currentOrientation = UIDevice.current.orientation
 
     var orientationStack = [UIInterfaceOrientationMask.all]
     var orientationMask: UIInterfaceOrientationMask = QuickBrickViewController.initialOrientationMask
 
     override public var supportedInterfaceOrientations: UIInterfaceOrientationMask {
-        return orientationMask
+        orientationMask
     }
 
     override public var shouldAutorotate: Bool {
-        return true
+        true
     }
 
     static var initialOrientationMask: UIInterfaceOrientationMask {
@@ -43,7 +43,8 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
 
     static var isTabletPortrait: Bool {
         guard let value = FacadeConnector.connector?.storage?.sessionStorageValue(for: "isTabletPortrait",
-                                                                                  namespace: nil) else {
+                                                                                  namespace: nil)
+        else {
             return false
         }
         return value.boolValue
@@ -75,21 +76,21 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         }
     }
 
-    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
+    override func viewWillTransition(to _: CGSize, with _: UIViewControllerTransitionCoordinator) {
         ReactNativeEventEmitter.orientationChange(toOrientation: UIDevice.current.orientation, fromOrientation: currentOrientation)
         currentOrientation = UIDevice.current.orientation
     }
 
     override func viewWillAppear(_ animated: Bool) {
-      super.viewWillAppear(animated)
-      currentOrientation = UIDevice.current.orientation;
+        super.viewWillAppear(animated)
+        currentOrientation = UIDevice.current.orientation
     }
 
     private func mapOrientation(_ orientation: Int) -> UIInterfaceOrientationMask {
-        let JS_PORTAIT = 0x00000001
-        let JS_LANDSCAPE = 0x00000002 // landscapeRight: 2,
-        let JS_LANDSCAPE_REVERSED = 0x00000004
-        let JS_PORTAIT_REVERSED = 0x00000008
+        let JS_PORTAIT = 0x0000_0001
+        let JS_LANDSCAPE = 0x0000_0002 // landscapeRight: 2,
+        let JS_LANDSCAPE_REVERSED = 0x0000_0004
+        let JS_PORTAIT_REVERSED = 0x0000_0008
         let JS_LANDSCAPE_SENSOR = JS_LANDSCAPE | JS_LANDSCAPE_REVERSED
         let JS_PORTAIT_SENSOR = JS_PORTAIT | JS_PORTAIT_REVERSED
         let JS_FULL_SENSOR = JS_LANDSCAPE_SENSOR | JS_PORTAIT_SENSOR
@@ -144,7 +145,6 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
             if !UIDevice.current.orientation.isPortrait {
                 forceOrientation(UIInterfaceOrientation.portrait)
             }
-            break
         case UIInterfaceOrientationMask.landscape:
             if !UIDevice.current.orientation.isLandscape {
                 let statusBarOrientation = UIApplication.shared.statusBarOrientation
@@ -154,29 +154,24 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
                     forceOrientation(UIInterfaceOrientation.landscapeRight)
                 }
             }
-            break
         case UIInterfaceOrientationMask.landscapeRight:
             if UIDevice.current.orientation.rawValue != UIInterfaceOrientation.landscapeRight.rawValue {
                 forceOrientation(UIInterfaceOrientation.landscapeRight)
             }
-            break
         case UIInterfaceOrientationMask.landscapeLeft:
             if UIDevice.current.orientation.rawValue != UIInterfaceOrientation.landscapeLeft.rawValue {
                 forceOrientation(UIInterfaceOrientation.landscapeLeft)
             }
-            break
         case UIInterfaceOrientationMask.all:
             break
         case UIInterfaceOrientationMask.allButUpsideDown:
-            if !UIDevice.current.orientation.isLandscape && UIDevice.current.orientation.rawValue != UIInterfaceOrientation.portrait.rawValue {
+            if !UIDevice.current.orientation.isLandscape, UIDevice.current.orientation.rawValue != UIInterfaceOrientation.portrait.rawValue {
                 forceOrientation(UIInterfaceOrientation.portrait)
             }
-            break
         case UIInterfaceOrientationMask.portraitUpsideDown:
             if UIDevice.current.orientation.rawValue != UIInterfaceOrientation.portraitUpsideDown.rawValue {
                 forceOrientation(UIInterfaceOrientation.portraitUpsideDown)
             }
-            break
         default:
             break
         }
@@ -190,8 +185,8 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         UIDevice.current.setValue(orientation.rawValue, forKey: "orientation")
         UIViewController.attemptRotationToDeviceOrientation()
     }
-    
+
     override var prefersHomeIndicatorAutoHidden: Bool {
-        return homeIndicatorAutoHidden
+        homeIndicatorAutoHidden
     }
 }

package/apple/ios/ReactNative/ReactNativeManageriOS+UIApplicationDelegate.swift

@@ -9,8 +9,8 @@ import Foundation
 import React
 import ZappCore
 
-extension ReactNativeManager {
-    func getLink(userInfo: [AnyHashable: Any]) -> String? {
+public extension ReactNativeManager {
+    internal func getLink(userInfo: [AnyHashable: Any]) -> String? {
         if let url = userInfo["url"] as? String {
             return url
         } else if let url = userInfo["^d"] as? String {
@@ -21,34 +21,31 @@ extension ReactNativeManager {
         return nil
     }
 
-    public func application(_ application: UIApplication,
-                            didReceiveRemoteNotification userInfo: [AnyHashable: Any]) {
-    }
+    func application(_: UIApplication,
+                     didReceiveRemoteNotification _: [AnyHashable: Any]) {}
 
-    public func application(_ application: UIApplication,
-                            didReceiveRemoteNotification userInfo: [AnyHashable: Any],
-                            fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    func application(_: UIApplication,
+                     didReceiveRemoteNotification userInfo: [AnyHashable: Any],
+                     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void)
+    {
         let userInfo = userInfo
         if let urlString = getLink(userInfo: userInfo),
-            let url = URL(string: urlString) {
+           let url = URL(string: urlString)
+        {
             UIApplication.shared.open(url,
                                       options: [:],
                                       completionHandler: nil)
-            
         }
         completionHandler(UIBackgroundFetchResult.newData)
-
     }
 
-    public func applicationWillResignActive(_ application: UIApplication) {
+    func applicationWillResignActive(_: UIApplication) {
         UIApplication.shared.applicationIconBadgeNumber = 0
     }
 
-    public func application(_ application: UIApplication,
-                            didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
-    }
+    func application(_: UIApplication,
+                     didRegisterForRemoteNotificationsWithDeviceToken _: Data) {}
 
-    public func application(_ application: UIApplication,
-                            didFailToRegisterForRemoteNotificationsWithError error: Error) {
-    }
+    func application(_: UIApplication,
+                     didFailToRegisterForRemoteNotificationsWithError _: Error) {}
 }

package/apple/ios/ReactNativeEventEmitter.swift

@@ -8,28 +8,26 @@
 import Foundation
 import React
 
-
 @objc(ReactNativeEventEmitter)
 open class ReactNativeEventEmitter: RCTEventEmitter {
-  public static var emitter: RCTEventEmitter!
-  
-  public static func orientationChange(toOrientation: UIDeviceOrientation, fromOrientation: UIDeviceOrientation) {
-    if (toOrientation.rawValue > 0) {
-      emitter.sendEvent(withName: "orientationChange", body: ["toOrientation": toOrientation.mapOrientation(), "fromOrientation": fromOrientation.mapOrientation()])
+    public static var emitter: RCTEventEmitter!
+
+    public static func orientationChange(toOrientation: UIDeviceOrientation, fromOrientation: UIDeviceOrientation) {
+        if toOrientation.rawValue > 0 {
+            emitter.sendEvent(withName: "orientationChange", body: ["toOrientation": toOrientation.mapOrientation(), "fromOrientation": fromOrientation.mapOrientation()])
+        }
+    }
+
+    override init() {
+        super.init()
+        ReactNativeEventEmitter.emitter = self
     }
-  }
-  
-  override init() {
-      super.init()
-      ReactNativeEventEmitter.emitter = self
-  }
-  
-  override open func supportedEvents() -> [String] {
-      return ["orientationChange"]
-  }
-  
-  override public class func requiresMainQueueSetup() -> Bool {
-      return true
-  }
-}
 
+    override open func supportedEvents() -> [String] {
+        ["orientationChange"]
+    }
+
+    override public class func requiresMainQueueSetup() -> Bool {
+        true
+    }
+}

package/apple/tvos/Helpers/FocusableGroupManager/FocusableGroupManager.swift

@@ -10,23 +10,23 @@ import Foundation
 import React
 
 /// Storage for focusable groups view [GroupID:FocusableGroupViewInstance]
-var focusableGroups:[String:FocusableGroupView] = [:]
+var focusableGroups: [String: FocusableGroupView] = [:]
 
 /// Storage for focusable views [GroupID:[ViewID:FocusableViewIntance]]
-var itemsGroups:[String:[String:FocusableView]] = [:]
+var itemsGroups: [String: [String: FocusableView]] = [:]
 
 /// Class control focusable group view with focusable items
 class FocusableGroupManager {
-    
     /// Register FocusableView at storage
     ///
     /// - Parameter item: FocusableView instance
-    class func registerView(item:FocusableView) -> Bool {
+    class func registerView(item: FocusableView) -> Bool {
         guard let itemId = item.itemId,
-        let groupId = item.groupId else {
+              let groupId = item.groupId
+        else {
             return false
         }
-        var newItemsGroup:[String:FocusableView] = [:]
+        var newItemsGroup: [String: FocusableView] = [:]
         if let itemsGroup = itemsGroups[groupId] {
             newItemsGroup = itemsGroup
         }
@@ -39,7 +39,7 @@ class FocusableGroupManager {
     /// Register FocusableGroup at storage
     ///
     /// - Parameter item: FocusableGroup instance
-    class func registerFocusableGroup(group:FocusableGroupView) -> Bool {
+    class func registerFocusableGroup(group: FocusableGroupView) -> Bool {
         var retVal = false
 
         if let id = group.itemId {
@@ -47,35 +47,34 @@ class FocusableGroupManager {
             retVal = true
         }
         return retVal
-
     }
-    
+
     /// Retrieve group by ID
     ///
     /// - Parameter groupID:  ID of the group
     /// - Returns: FocusableGroupView instance if registered into manager
-    class func group(by groupID:String) -> FocusableGroupView? {
+    class func group(by groupID: String) -> FocusableGroupView? {
         guard let groupView = focusableGroups[groupID] else {
             return nil
         }
         return groupView
     }
-    
+
     /// Retrieve All items that connected to Group
     ///
     /// - Parameter groupID: ID of the group
     /// - Returns: Dictionary in format [ViewID:FocusableViewIntance]
-    class func itemsForGroup(by groupID:String) -> [String:FocusableView] {
+    class func itemsForGroup(by groupID: String) -> [String: FocusableView] {
         guard let groupViewsDict = itemsGroups[groupID] else {
             return [:]
         }
         return groupViewsDict
     }
-    
+
     /// Notify group view that item relevant to it was updated
     ///
     /// - Parameter groupID: ID of the group
-    class func notifyGroupView(groupID:String) {
+    class func notifyGroupView(groupID: String) {
         DispatchQueue.main.async {
             guard let groupView = focusableGroups[groupID] else {
                 return
@@ -84,19 +83,19 @@ class FocusableGroupManager {
             groupView.groupItemsUpdated(groupItems: groupItems)
         }
     }
-    
+
     /// Retrieve FocusableView view instance
     ///
     /// - Parameters:
     ///   - groupId: Id of the group
     ///   - itemId: Id of the FocusableView to search
     /// - Returns: FocusableView instance if exist in searched group, otherwise nil
-    class func item(byGroupId groupId:String,
-                    andItemId itemId:String) -> FocusableView? {
-        return itemsForGroup(by: groupId).first(where: {$0.key == itemId})?.value
+    class func item(byGroupId groupId: String,
+                    andItemId itemId: String) -> FocusableView?
+    {
+        itemsForGroup(by: groupId).first(where: { $0.key == itemId })?.value
     }
-    
-    
+
     /// Make focus item focusable if exists and registered
     ///
     /// - Parameters:
@@ -104,38 +103,40 @@ class FocusableGroupManager {
     ///   - itemId: Id of the focusable item
     ///   - needsForceUpdate: if value is true after make item as preferred item focus, It will also request Focus Engine to focus immidiately
     ///   - completion: completion block in case need, that will be called when focusable item did focus
-    class func updateFocus(_ groupId: String?, itemId: String?, needsForceUpdate:Bool = false, completion:((_ success:Bool) -> Void)? = nil) {
+    class func updateFocus(_ groupId: String?, itemId: String?, needsForceUpdate: Bool = false, completion: ((_ success: Bool) -> Void)? = nil) {
         DispatchQueue.main.async {
-            
             if let groupId = groupId,
-                let itemId = itemId,
-                let groupView = focusableGroups[groupId],
-                let viewToFocus = FocusableGroupManager.item(byGroupId: groupId,
-                                                             andItemId: itemId) {
+               let itemId = itemId,
+               let groupView = focusableGroups[groupId],
+               let viewToFocus = FocusableGroupManager.item(byGroupId: groupId,
+                                                            andItemId: itemId)
+            {
                 groupView.updatePrefferedFocusEnv(with: viewToFocus)
-                
-                var rootView:UIView? = groupView
-                while(rootView !== nil && rootView?.isReactRootView() == false) {
+
+                var rootView: UIView? = groupView
+                while rootView !== nil, rootView?.isReactRootView() == false {
                     if let unwrapedRootView = rootView,
-                        let superView = unwrapedRootView.superview {
+                       let superView = unwrapedRootView.superview
+                    {
                         rootView = superView
                     } else {
                         rootView = nil
                     }
                 }
-                
+
                 if rootView == nil {
                     return
                 }
-                
+
                 if let rootView = rootView,
-                    let superView = rootView.superview as? RCTRootView {
+                   let superView = rootView.superview as? RCTRootView
+                {
                     superView.reactPreferredFocusedView = viewToFocus
                     if needsForceUpdate == true {
                         superView.setNeedsFocusUpdate()
                         superView.updateFocusIfNeeded()
                         var completionWasCalled = false
-                        
+
                         // Timeout 2 seconds if did focus was not called by some reason, we are passing completion
                         DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
                             if completionWasCalled == false {
@@ -143,16 +144,15 @@ class FocusableGroupManager {
                                 groupView.didFocusCallBack = nil
                             }
                         }
-                        
-                        groupView.didFocusCallBack = (completion:{
+
+                        groupView.didFocusCallBack = (completion: {
                             completionWasCalled = true
                             completion?(true)
-                            
-                        }, focusableItemId:itemId)
+
+                        }, focusableItemId: itemId)
                     }
                 }
             }
         }
     }
 }
-

package/apple/tvos/Helpers/FocusableGroupManager/FocusableManagerModule.swift

@@ -13,29 +13,26 @@ let kFocusableManagerModule = "FocusableManagerModule"
 
 @objc(FocusableManagerModule)
 class FocusableManagerModule: NSObject, RCTBridgeModule {
-    
     /// Delay timer before focus will be invoked, was done to resolve async problems.
     /// Sometimes focusale item did has superview when it render that may cayse glitches.
     var delayTimer = 100
-    
+
     /// main React bridge
     public var bridge: RCTBridge?
-    
-    
+
     static func moduleName() -> String! {
-        return kFocusableManagerModule
+        kFocusableManagerModule
     }
-    
+
     public class func requiresMainQueueSetup() -> Bool {
-        return true
+        true
     }
-    
+
     /// prefered thread on which to run this native module
     @objc public var methodQueue: DispatchQueue {
-        return DispatchQueue.main
+        DispatchQueue.main
     }
-    
-    
+
     /// Updates next preffered focus item for focusable group
     ///
     /// - Parameters:
@@ -45,32 +42,30 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
     @objc func setPreferredFocus(_ groupId: String?, itemId: String?) {
         // We need delay to make sure that on native side group will have superview
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
-        
-        DispatchQueue.main.asyncAfter(deadline: delay)  {
+
+        DispatchQueue.main.asyncAfter(deadline: delay) {
             FocusableGroupManager.updateFocus(groupId,
                                               itemId: itemId)
         }
-        
     }
-    
+
     /// Force updates next preffered focus item for focusable group
     ///
     /// - Parameters:
     ///   - groupId: id of the focusable group
     ///   - itemId: id of the focusable item
     /// - Note: This method is forcing focus engine to focus on focusable item in focusable group
-    @objc func forceFocus(_ groupId: String?, itemId: String?, callback:RCTResponseSenderBlock?) {
+    @objc func forceFocus(_ groupId: String?, itemId: String?, callback: RCTResponseSenderBlock?) {
         // We need delay to make sure that on native side group will have superview
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
-        
-        DispatchQueue.main.asyncAfter(deadline: delay)  {
+
+        DispatchQueue.main.asyncAfter(deadline: delay) {
             FocusableGroupManager.updateFocus(groupId,
                                               itemId: itemId,
-                                              needsForceUpdate: true, completion: { (succeed) in
-                                                callback?([succeed])
-                                                
-            })
+                                              needsForceUpdate: true, completion: { succeed in
+                                                  callback?([succeed])
+
+                                              })
         }
     }
 }
-