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

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

@@ -10,9 +10,10 @@ 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])
     }
 }

package/apple/tvos/ReactNative/QuickBrickViewController.swift

@@ -8,12 +8,12 @@
 import UIKit
 
 class QuickBrickViewController: UIViewController {
-    public func allowOrientationForScreen(_ orientation:Int) {
-        //not implemented
+    public func allowOrientationForScreen(_: Int) {
+        // not implemented
     }
 
     /// Release Orientation for specific screen to previous state
     public func releaseOrientationForScreen() {
-        //not implemented
+        // not implemented
     }
 }

package/apple/tvos/Views/FocusableGroupView/FocusableGroupView.swift

@@ -7,63 +7,64 @@
 //
 
 import Foundation
-import UIKit
 import React
+import UIKit
 
 /// Focusable  Group View that implements UIFocusGuide instance that catches focus event
-public class FocusableGroupView:RCTTVView {
-    
+public class FocusableGroupView: RCTTVView {
     /// Completion that will be used when focus manager forcing to update focusable group
-    var didFocusCallBack:(completion:(() -> ()), focusableItemId:String)?
-    
+    var didFocusCallBack: (completion: () -> Void, focusableItemId: String)?
+
     /// This parameter blocks focus behavior without user interaction, it is used to prevent fast jumps between items
     @objc public var isManuallyBlockingFocusValue: NSNumber?
-    
+
     private var isManuallyBlockingFocus: Bool = false
-    
+
     /// Notify React-Native environment that Focus Did Update
-    @objc public var onDidUpdateFocus:RCTBubblingEventBlock?
-    
+    @objc public var onDidUpdateFocus: RCTBubblingEventBlock?
+
     /// Notify React-Native environment that Focus Will Update
-    @objc public var onWillUpdateFocus:RCTBubblingEventBlock?
-    
+    @objc public var onWillUpdateFocus: RCTBubblingEventBlock?
+
     /// Define if focus enabled for current view
-    @objc public var isFocusDisabled:Bool = false
-    
+    @objc public var isFocusDisabled: Bool = false
+
     /// Current group will try to find initial index id in groups
-    @objc public var dependantGroupIds:[String]?
-    
+    @objc public var dependantGroupIds: [String]?
+
     /// Check if preferred focus has to be reset to initial value, after group becomes inactive
-    @objc public var resetFocusToInitialValue:Bool = false
-    
+    @objc public var resetFocusToInitialValue: Bool = false
+
     /// ID of the item that must be focused as init focus
-    @objc public var initialItemId:String?
-    
+    @objc public var initialItemId: String?
+
     /// ID of the Connected GroupView provided by React-Native env
-    @objc public var itemId:String? {
-        didSet{
+    @objc public var itemId: String? {
+        didSet {
             if itemId != oldValue {
                 _ = FocusableGroupManager.registerFocusableGroup(group: self)
             }
         }
     }
-    
+
     /// ID of the parent group, if relevant
-    @objc public var groupId:String?
-    
+    @objc public var groupId: String?
+
     /// If this variable not nil it overrides default preffered focus environment
-    var customPrefferedFocusEnvironment:[UIFocusEnvironment]? {
+    var customPrefferedFocusEnvironment: [UIFocusEnvironment]? {
         didSet {
-            var rootView:UIView? = self
+            var rootView: UIView? = self
 
-            while(rootView?.superview != nil) {
+            while rootView?.superview != nil {
                 if let unwrapedRootView = rootView,
-                    let superView = unwrapedRootView.superview {
+                   let superView = unwrapedRootView.superview
+                {
                     rootView = superView
                     if let superFocusGroup = rootView as? FocusableGroupView {
                         if let newFocusData = customPrefferedFocusEnvironment as? [FocusableView],
-                            let superFocusGroupFocusEnvironment = superFocusGroup.customPrefferedFocusEnvironment as? [FocusableView] {
-                            let groupIdsToStay = newFocusData.map({$0.groupId})
+                           let superFocusGroupFocusEnvironment = superFocusGroup.customPrefferedFocusEnvironment as? [FocusableView]
+                        {
+                            let groupIdsToStay = newFocusData.map(\.groupId)
                             let filteredGroups = superFocusGroupFocusEnvironment.filter { !groupIdsToStay.contains($0.groupId) }
                             superFocusGroup.customPrefferedFocusEnvironment = filteredGroups + newFocusData
                         } else {
@@ -72,9 +73,9 @@ public class FocusableGroupView:RCTTVView {
                     }
                 }
             }
-       
         }
     }
+
     /// Check if group has an initial focus
     /// Note: In case Initial init when app start not calling shouldFocusUpdate
     var isGroupWasFocusedByUser = false
@@ -82,20 +83,21 @@ public class FocusableGroupView:RCTTVView {
     /// View connected to GroupView was updated
     ///
     /// - Parameter groupItems: dictionary connected to group view
-    public func groupItemsUpdated(groupItems:[String:FocusableView]) {
+    public func groupItemsUpdated(groupItems: [String: FocusableView]) {
         guard
-            self.isGroupWasFocusedByUser == false,
+            isGroupWasFocusedByUser == false,
             let initialItemId = initialItemId,
-            let initialView = groupItems[initialItemId] else {
-                return
+            let initialView = groupItems[initialItemId]
+        else {
+            return
         }
-        
+
         let focusedView = customPrefferedFocusEnvironment?.first as? UIView
         if focusedView != initialView || focusedView == nil {
             customPrefferedFocusEnvironment = [initialView]
         }
     }
-    
+
     /// Reset focus to initial state if needed
     ///
     /// - Parameter nextFocusedItem: next item that should be focused
@@ -105,15 +107,17 @@ public class FocusableGroupView:RCTTVView {
         guard let nextFocusedItem = nextFocusedItem else {
             return retVal
         }
-        
+
         if focusItemIsDescendant(nextFocuseItem: nextFocusedItem) == false {
             if resetFocusToInitialValue,
-                let initialItemId = initialItemId {
-                if self.tryTakePrefferedViewFromDependantGroups() == false {
+               let initialItemId = initialItemId
+            {
+                if tryTakePrefferedViewFromDependantGroups() == false {
                     if let groupId = groupId,
-                        let initialItemView = FocusableGroupManager.item(byGroupId: groupId,
-                                                                         andItemId: initialItemId) {
-                        self.customPrefferedFocusEnvironment = [initialItemView]
+                       let initialItemView = FocusableGroupManager.item(byGroupId: groupId,
+                                                                        andItemId: initialItemId)
+                    {
+                        customPrefferedFocusEnvironment = [initialItemView]
                         retVal = true
                     }
                 } else {
@@ -123,71 +127,71 @@ public class FocusableGroupView:RCTTVView {
         }
         return retVal
     }
-    
+
     /// Try to focus on preffered item from another group
     ///
     /// - Returns: true if can focus otherwise false
     func tryTakePrefferedViewFromDependantGroups() -> Bool {
         guard let initialItemId = initialItemId,
-            let dependantGroupIds = dependantGroupIds,
-            
-            let firstGroupId = dependantGroupIds.first,
-            let initialView = FocusableGroupManager.item(byGroupId: firstGroupId,
-                                                         andItemId: initialItemId) else {
-                                                            return false
+              let dependantGroupIds = dependantGroupIds,
+
+              let firstGroupId = dependantGroupIds.first,
+              let initialView = FocusableGroupManager.item(byGroupId: firstGroupId,
+                                                           andItemId: initialItemId)
+        else {
+            return false
         }
 
         customPrefferedFocusEnvironment = [initialView]
-        
+
         return true
     }
-    
+
     /// Focus guide that will catch the focus of the groups
     var focusGuide = UIFocusGuide()
-    
+
     /// Manager that connects View instance to FocusableGroupViewModule
-    var manager:FocusableGroupViewModule?
-    
+    var manager: FocusableGroupViewModule?
+
     public required init?(coder aDecoder: NSCoder) {
         super.init(coder: aDecoder)
         setupFocus()
     }
-    
-    public override init(frame: CGRect) {
+
+    override public init(frame: CGRect) {
         super.init(frame: frame)
         setupFocus()
     }
-    
+
     /// Update customPrefferedFocusEnvironment
     ///
     /// - Parameter view: view instance that should be preffered
-    func updatePrefferedFocusEnv(with view:FocusableView) {
+    func updatePrefferedFocusEnv(with view: FocusableView) {
         customPrefferedFocusEnvironment = [view]
     }
-    
+
     /// Setup Focus Guide for use
     func setupFocus() {
-        self.addLayoutGuide(focusGuide)
-        
-        focusGuide.leftAnchor.constraint(equalTo: self.leftAnchor).isActive = true
-        focusGuide.topAnchor.constraint(equalTo: self.topAnchor).isActive = true
-        focusGuide.bottomAnchor.constraint(equalTo: self.bottomAnchor).isActive = true
-        focusGuide.rightAnchor.constraint(equalTo: self.rightAnchor).isActive = true
+        addLayoutGuide(focusGuide)
 
+        focusGuide.leftAnchor.constraint(equalTo: leftAnchor).isActive = true
+        focusGuide.topAnchor.constraint(equalTo: topAnchor).isActive = true
+        focusGuide.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
+        focusGuide.rightAnchor.constraint(equalTo: rightAnchor).isActive = true
     }
-    
+
     /// Send update focus event to Reactnative
     ///
     /// - Parameter context: Update UIFocusUpdateContext instance
-    func sendUpdateFocusEventToReactNative(bubbleEventBlock:RCTBubblingEventBlock?, context:UIFocusUpdateContext) {
-        guard let bubbleEventBlock = bubbleEventBlock  else {
+    func sendUpdateFocusEventToReactNative(bubbleEventBlock: RCTBubblingEventBlock?, context: UIFocusUpdateContext) {
+        guard let bubbleEventBlock = bubbleEventBlock else {
             return
         }
         let focusHeading = focusHeadingToString(focusHeading: context.focusHeading)
-        var params:[String:Any] = [GroupViewUpdateEvents.focusHeading:focusHeading];
-        
+        var params: [String: Any] = [GroupViewUpdateEvents.focusHeading: focusHeading]
+
         params[GroupViewUpdateEvents.isFocusingByUser] = focusHeading != FocusHeadingTextValues.manualUpdate
-        
+
         params[GroupViewUpdateEvents.previouslyFocusedItem] = dataForFocusItem(focusItem: context.previouslyFocusedView)
         params[GroupViewUpdateEvents.nextFocusedItem] = dataForFocusItem(focusItem: context.nextFocusedView)
         params[GroupViewUpdateEvents.prefferedFocusEnvironment] = dataForFocusItem(focusItem: customPrefferedFocusEnvironment?.first)
@@ -196,19 +200,20 @@ public class FocusableGroupView:RCTTVView {
         if let focusableView = context.nextFocusedItem as? FocusableView {
             params[GroupViewUpdateEvents.itemId] = focusableView.itemId
         }
-        
+
         if focusItemIsDescendant(nextFocuseItem: context.nextFocusedItem) {
             params[GroupViewUpdateEvents.isActive] = true
-            
+
         } else {
             params[GroupViewUpdateEvents.isActive] = false
             isFocusDisabled = false
             if resetFocusToInitialValue,
-                let initialItemId = initialItemId{
+               let initialItemId = initialItemId
+            {
                 if let groupId = groupId {
                     let groupItems = FocusableGroupManager.itemsForGroup(by: groupId)
                     if let initialItemView = groupItems[initialItemId] {
-                        self.customPrefferedFocusEnvironment = [initialItemView]
+                        customPrefferedFocusEnvironment = [initialItemView]
                     }
                 }
             }
@@ -217,15 +222,14 @@ public class FocusableGroupView:RCTTVView {
 
         bubbleEventBlock(params)
     }
- 
+
     /// Data for Focus Item that will be passed to React-Native env
     ///
     /// - Parameter focusItem: focu item instance
     /// - Returns: dictionary instance in case data exists, otherwise nil
-    func dataForFocusItem(focusItem: Any?) -> [String:Any]? {
-        var retVal = [String:Any]()
+    func dataForFocusItem(focusItem: Any?) -> [String: Any]? {
+        var retVal = [String: Any]()
         if let focusedView = focusItem as? RCTTVView {
-            
             retVal[FocusItemDataKeys.describingView] = String(describing: focusedView)
             if let reactTag = focusedView.reactTag?.stringValue {
                 retVal[FocusItemDataKeys.reactTag] = reactTag
@@ -234,36 +238,38 @@ public class FocusableGroupView:RCTTVView {
         }
         return retVal.keys.count == 0 ? nil : retVal
     }
-    
+
     /// Update preffered Focus View for focuse guide if next focuasable view is part of this focus guide
     ///
     /// - Parameter nextFocuseItem: next focus item instance
     func updatePreferredFocusView(nextFocuseItem: Any?) {
         guard let nextFocusView = nextFocuseItem as? UIView,
-            nextFocusView.isDescendant(of: self) else {
+              nextFocusView.isDescendant(of: self)
+        else {
             return
         }
 
         customPrefferedFocusEnvironment = [nextFocusView]
     }
-    
+
     /// Checks if next focus item is part of the current group
     ///
     /// - Parameter nextFocuseItem: next item to focus
     /// - Returns: true if next focus item part of this group instance
-    func focusItemIsDescendant(nextFocuseItem:Any?) -> Bool {
+    func focusItemIsDescendant(nextFocuseItem: Any?) -> Bool {
         guard let nextFocusView = nextFocuseItem as? UIView,
-            nextFocusView.isDescendant(of: self) else {
-                return false
+              nextFocusView.isDescendant(of: self)
+        else {
+            return false
         }
         return true
     }
-    
+
     /// Mapping focus enum to readable string
     ///
     /// - Parameter focusHeading: UIFocusHeading enum
     /// - Returns: Readable string from enum
-    func focusHeadingToString(focusHeading:UIFocusHeading) -> String {
+    func focusHeadingToString(focusHeading: UIFocusHeading) -> String {
         switch focusHeading {
         case UIFocusHeading.up:
             return FocusHeadingTextValues.up
@@ -281,48 +287,47 @@ public class FocusableGroupView:RCTTVView {
             return FocusHeadingTextValues.manualUpdate
         }
     }
-    
+
     /// Force manually focus update
     func manuallyBlockFocus() {
         if let isManuallyBlockingFocusValue = isManuallyBlockingFocusValue {
             isManuallyBlockingFocus = true
             let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(Int(isManuallyBlockingFocusValue.floatValue * 1000))
 
-            DispatchQueue.main.asyncAfter(deadline: delay)  { [weak self] in
+            DispatchQueue.main.asyncAfter(deadline: delay) { [weak self] in
                 self?.isManuallyBlockingFocus = false
             }
         }
     }
-    
-    //MARK: Focus Engine
-    
-    public override var preferredFocusEnvironments: [UIFocusEnvironment] {
+
+    // MARK: Focus Engine
+
+    override public var preferredFocusEnvironments: [UIFocusEnvironment] {
         if let customPrefferedFocusEnvironment = customPrefferedFocusEnvironment {
             return customPrefferedFocusEnvironment
         }
         return super.preferredFocusEnvironments
     }
-    
-    public override func shouldUpdateFocus(in context: UIFocusUpdateContext) -> Bool {
+
+    override public func shouldUpdateFocus(in context: UIFocusUpdateContext) -> Bool {
         guard isFocusDisabled == false,
-            isManuallyBlockingFocus == false
-            else {
+              isManuallyBlockingFocus == false
+        else {
 //                 Ignoring focus events that blocks by native side for purpose (maybe changed if future)
-                if isManuallyBlockingFocus == false {
-                
-                    sendUpdateFocusEventToReactNative(bubbleEventBlock:onWillUpdateFocus,
-                                                      context: context)
-                }
-                return false
+            if isManuallyBlockingFocus == false {
+                sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
+                                                  context: context)
+            }
+            return false
         }
 
         isGroupWasFocusedByUser = true
-   
+
         if resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: context.nextFocusedItem) == false {
             updatePreferredFocusView(nextFocuseItem: context.nextFocusedItem)
         }
 
-        sendUpdateFocusEventToReactNative(bubbleEventBlock:onWillUpdateFocus,
+        sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
                                           context: context)
 
         if focusItemIsDescendant(nextFocuseItem: context.nextFocusedItem) == false {
@@ -331,26 +336,25 @@ public class FocusableGroupView:RCTTVView {
         return true
     }
 
- 
     override public func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
         super.didUpdateFocus(in: context, with: coordinator)
         manuallyBlockFocus()
         tryDidFocusCallCallback(context: context)
-        sendUpdateFocusEventToReactNative(bubbleEventBlock:onDidUpdateFocus,
+        sendUpdateFocusEventToReactNative(bubbleEventBlock: onDidUpdateFocus,
                                           context: context)
     }
-    
-    
+
     /// Try to send a callback in case focus manager request callback during force focus update
     ///
     /// - Parameter context: An instance of UIFocusUpdateContext containing metadata of the focus related update.
     func tryDidFocusCallCallback(context: UIFocusUpdateContext) {
         guard let callbackData = didFocusCallBack,
-            let fousedView = context.nextFocusedView as? FocusableView,
-            let itemId = fousedView.itemId else {
-                return
+              let fousedView = context.nextFocusedView as? FocusableView,
+              let itemId = fousedView.itemId
+        else {
+            return
         }
-        
+
         let completion = callbackData.completion
         let focusableItemId = callbackData.focusableItemId
         if itemId == focusableItemId {

package/apple/tvos/Views/FocusableGroupView/FocusableGroupViewConsts.swift

@@ -7,32 +7,32 @@
 //
 
 /// Defines Keys that will be passed for focus event heading
-public struct FocusHeadingTextValues {
-    static let up           = "Up"
-    static let down         = "Down"
-    static let left         = "Left"
-    static let right        = "Right"
-    static let next         = "Next"
-    static let previous     = "Previous"
+public enum FocusHeadingTextValues {
+    static let up = "Up"
+    static let down = "Down"
+    static let left = "Left"
+    static let right = "Right"
+    static let next = "Next"
+    static let previous = "Previous"
     static let manualUpdate = "Posible manual update or initial focus by tvOS"
 }
 
 /// Group view events that will be passed to React-Native env
-public struct GroupViewUpdateEvents {
-    static let focusHeading              = "focusHeading"
-    static let previouslyFocusedItem     = "previouslyFocusedItem"
-    static let nextFocusedItem           = "nextFocusedItem"
+public enum GroupViewUpdateEvents {
+    static let focusHeading = "focusHeading"
+    static let previouslyFocusedItem = "previouslyFocusedItem"
+    static let nextFocusedItem = "nextFocusedItem"
     static let prefferedFocusEnvironment = "prefferedFocusEnvironment"
-    static let groupId                   = "groupId"
-    static let itemId                    = "itemId"
-    static let isActive                  = "isActive"
-    static let isFocusDisabled           = "isFocusDisabled"
-    static let isFocusingByUser          = "isFocusingByUser"
+    static let groupId = "groupId"
+    static let itemId = "itemId"
+    static let isActive = "isActive"
+    static let isFocusDisabled = "isFocusDisabled"
+    static let isFocusingByUser = "isFocusingByUser"
 }
 
 /// Keys that will be passed to React-Native env for GroupViewUpdateEvents with `previouslyFocusedItem` and `nextFocusedItem`
-public struct FocusItemDataKeys {
+public enum FocusItemDataKeys {
     static let describingView = "describingView"
-    static let reactTag       = "reactTag"
-    static let isDescendant   = "isDescendant"
+    static let reactTag = "reactTag"
+    static let isDescendant = "isDescendant"
 }

package/apple/tvos/Views/FocusableGroupView/FocusableGroupViewModule.swift

@@ -12,29 +12,29 @@ import React
 @objc(FocusableGroupViewModule)
 public class FocusableGroupViewModule: RCTViewManager {
     static let focusableGroupViewModuleName = "FocusableGroupViewModule"
-    
+
     override public static func moduleName() -> String? {
-        return focusableGroupViewModuleName
+        focusableGroupViewModuleName
     }
-    
+
     override public class func requiresMainQueueSetup() -> Bool {
-        return true
+        true
     }
-    
+
     override open var methodQueue: DispatchQueue {
-        return bridge.uiManager.methodQueue
+        bridge.uiManager.methodQueue
     }
-    
+
     override public func view() -> UIView? {
         let retVal = FocusableGroupView()
         retVal.manager = self
         return retVal
     }
-    
-    public func viewFromReactTag(reactTag:NSNumber?) -> RCTTVView? {
+
+    public func viewFromReactTag(reactTag: NSNumber?) -> RCTTVView? {
         guard let reactTag = reactTag else {
             return nil
         }
-        return self.bridge.uiManager.view(forReactTag: reactTag) as? RCTTVView
+        return bridge.uiManager.view(forReactTag: reactTag) as? RCTTVView
     }
 }

package/apple/tvos/Views/FocusableView/FocusableView+ParallaxViewDelegate.swift

@@ -8,42 +8,36 @@
 
 import Foundation
 
-extension FocusableView:ParallaxViewDelegate {
-    public func parallaxViewWillFocus(_ parallaxView: ParallaxView) {
+extension FocusableView: ParallaxViewDelegate {
+    public func parallaxViewWillFocus(_: ParallaxView) {
         guard let onFocus = onViewFocus else {
             return
         }
         onFocus(eventData())
     }
-    
-    public func parallaxViewDidFocus(_ parallaxView: ParallaxView) {
 
-    }
-    
-    public func parallaxViewWillUnfocus(_ parallaxView: ParallaxView) {
+    public func parallaxViewDidFocus(_: ParallaxView) {}
+
+    public func parallaxViewWillUnfocus(_: ParallaxView) {
         guard let onBlur = onViewBlur else {
             return
         }
         onBlur(eventData())
     }
-    
-    public func parallaxViewDidUnfocus(_ parallaxView: ParallaxView) {
-        
-    }
-    
-    public func parallaxViewWillSelected(_ parallaxView: ParallaxView) {
-        
-    }
-    
-    public func parallaxViewDidSelected(_ parallaxView: ParallaxView) {
+
+    public func parallaxViewDidUnfocus(_: ParallaxView) {}
+
+    public func parallaxViewWillSelected(_: ParallaxView) {}
+
+    public func parallaxViewDidSelected(_: ParallaxView) {
         guard let onPress = onViewPress else {
             return
         }
         onPress(eventData())
     }
-    
-    func eventData() -> [String:Any] {
-        var retVal:[String:Any] = [:]
+
+    func eventData() -> [String: Any] {
+        var retVal: [String: Any] = [:]
         retVal["tag"] = reactTag
         retVal["itemID"] = itemId
         return retVal