@applicaster/quick-brick-native-apple 6.15.3 → 6.16.1

package/apple/QuickBrickApple.podspec.json

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

package/apple/ios/ReactNative/PushBridge.swift

@@ -21,12 +21,12 @@ class PushBridge: NSObject, RCTBridgeModule {
         "PushBridge"
     }
 
-    public class func requiresMainQueueSetup() -> Bool {
+    class func requiresMainQueueSetup() -> Bool {
         true
     }
 
     /// prefered thread on which to run this native module
-    @objc public var methodQueue: DispatchQueue {
+    @objc var methodQueue: DispatchQueue {
         DispatchQueue.main
     }
 

package/apple/ios/ReactNative/QuickBrickViewController.swift

@@ -20,7 +20,7 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
 
     var orientationMask: UIInterfaceOrientationMask = QuickBrickViewController.initialOrientationMask
 
-    override public var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
         orientationMask
     }
 
@@ -28,7 +28,7 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         homeIndicatorAutoHidden
     }
 
-    override public var shouldAutorotate: Bool {
+    override var shouldAutorotate: Bool {
         true
     }
 
@@ -64,7 +64,7 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         UIDevice.current.orientation
     }
 
-    public func allowOrientationForScreen(_ orientation: ReactNativeOrientation) {
+    func allowOrientationForScreen(_ orientation: ReactNativeOrientation) {
         orientationMask = orientation.toInterfaceOrientationMask()
         forceOrientationWithMaskIfNeeded(orientationMask)
     }

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

@@ -44,8 +44,8 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
 
         DispatchQueue.main.asyncAfter(deadline: delay) {
-            FocusableGroupManager.shared.updateFocus(groupId: groupId,
-                                                     itemId: itemId)
+            GroupProxyManager.shared.updateFocus(groupId: groupId,
+                                                 itemId: itemId)
         }
     }
 
@@ -60,13 +60,13 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
 
         DispatchQueue.main.asyncAfter(deadline: delay) {
-            FocusableGroupManager.shared.updateFocus(groupId: groupId,
-                                                     itemId: itemId,
-                                                     needsForceUpdate: true,
-                                                     completion: { succeed in
-                                                         callback?([succeed])
+            GroupProxyManager.shared.updateFocus(groupId: groupId,
+                                                 itemId: itemId,
+                                                 needsForceUpdate: true,
+                                                 completion: { succeed in
+                                                     callback?([succeed])
 
-                                                     })
+                                                 })
         }
     }
 }

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

@@ -0,0 +1,128 @@
+//
+//  GroupProxy.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 12/19/24.
+//
+
+import Foundation
+import XrayLogger
+
+class GroupProxy {
+    let groupId: String
+    private weak var group: FocusableGroupView?
+    private var children: [WeakBox<FocusableView>] = []
+    private let lock = NSLock()
+
+    var delayedPreferredFocus: FocusableView?
+
+    private lazy var logger = Logger.getLogger(for: "QuickBrickApple/FocusableGroupManager/GroupProxy")
+
+    init(groupId: String) {
+        self.groupId = groupId
+    }
+
+    // MARK: - Child Management
+
+    func addChild(_ view: FocusableView) {
+        lock.lock()
+        children.append(WeakBox(view))
+        lock.unlock()
+    }
+
+    func removeChild(_ view: FocusableView) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        children.removeAll { $0.value === view }
+
+        if children.isEmpty, group == nil {
+            GroupProxyManager.shared.removeProxy(forGroupId: groupId)
+        }
+
+        if delayedPreferredFocus === view {
+            delayedPreferredFocus = nil
+        }
+    }
+
+    // MARK: - Group Binding
+
+    @MainActor func bindGroup(_ group: FocusableGroupView) {
+        // Check for duplicate group binding
+        if let existingGroup = self.group {
+            logger?.warningLog(message: """
+            ⚠️ Duplicate group binding detected for groupId: '\(groupId)'
+               Previous group: \(existingGroup.debugDescription)
+               New group: \(group.debugDescription)
+               Overwriting previous binding.
+            """)
+
+            #if DEBUG
+                // assertionFailure("Duplicate group binding for groupId '\(groupId)'. Check React Native component IDs.")
+            #endif
+        }
+
+        self.group = group
+
+        if let preferredFocusView = delayedPreferredFocus {
+            applyPreferredFocus(group,
+                                view: preferredFocusView)
+            delayedPreferredFocus = nil
+        }
+    }
+
+    func unbindGroup() {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if children.isEmpty {
+            GroupProxyManager.shared.removeProxy(forGroupId: groupId)
+        }
+
+        group = nil
+    }
+
+    // MARK: - Preferred Focus
+
+    @MainActor private func applyPreferredFocus(_ currentGroup: FocusableGroupView, view: FocusableView) {
+        if view.preferredFocus {
+            currentGroup.setUserPreferredFocusEnvironments([view])
+        } else if let currentPreferred = currentGroup.getUserPreferredFocusEnvironments()?.first as? FocusableView,
+                  currentPreferred === view {
+            currentGroup.setUserPreferredFocusEnvironments(nil)
+        }
+    }
+
+    @MainActor func updatePreferredFocus(_ view: FocusableView) {
+        lock.lock()
+        let currentGroup = group
+        lock.unlock()
+
+        if let currentGroup {
+            applyPreferredFocus(currentGroup,
+                                view: view)
+        } else {
+            if view.preferredFocus {
+                delayedPreferredFocus = view
+            }
+        }
+    }
+
+    /// Get the bound group (if any)
+    func getGroup() -> FocusableGroupView? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        return group
+    }
+}
+
+// MARK: - WeakBox Helper
+
+private class WeakBox<T: AnyObject> {
+    weak var value: T?
+
+    init(_ value: T) {
+        self.value = value
+    }
+}

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

@@ -0,0 +1,101 @@
+//
+//  GroupProxyManager.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 12/19/24.
+//
+
+import Foundation
+import React
+
+class GroupProxyManager {
+    static let shared = GroupProxyManager()
+
+    private let lock = NSLock()
+    private var proxies: [GroupProxy] = []
+
+    private init() {}
+
+    // MARK: - Proxy Access
+
+    func getOrCreateProxy(forGroupId groupId: String) -> GroupProxy {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if let existing = proxies.first(where: { $0.groupId == groupId }) {
+            return existing
+        }
+
+        let proxy = GroupProxy(groupId: groupId)
+        proxies.append(proxy)
+        return proxy
+    }
+
+    // MARK: - Cleanup
+
+    func removeProxy(forGroupId groupId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        proxies.removeAll { $0.groupId == groupId }
+    }
+
+    // MARK: - Focus Update
+
+    func updateFocus(groupId: String?,
+                     itemId: String?,
+                     needsForceUpdate: Bool = false,
+                     completion: ((Bool) -> Void)? = nil) {
+        guard let groupId,
+              let itemId else {
+            completion?(false)
+            return
+        }
+
+        lock.lock()
+        let proxy = proxies.first(where: { $0.groupId == groupId })
+        lock.unlock()
+
+        guard let proxy,
+              let groupView = proxy.getGroup() else {
+            completion?(false)
+            return
+        }
+
+        DispatchQueue.main.async {
+            var rootView: UIView? = groupView
+
+            while let unwrapedRootView = rootView,
+                  !unwrapedRootView.isReactRootView() {
+                rootView = rootView?.superview
+            }
+
+            guard let rootViewUnwrapped = rootView,
+                  let superView = rootViewUnwrapped.superview as? RCTRootView else {
+                completion?(false)
+                return
+            }
+
+            if needsForceUpdate {
+                superView.setNeedsFocusUpdate()
+                superView.updateFocusIfNeeded()
+
+                let timeout: TimeInterval = 2.0
+
+                groupView.didFocusCallBack = (completion: {
+                    completion?(true)
+                    groupView.didFocusCallBack = nil
+                }, focusableItemId: itemId)
+
+                DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
+                    if groupView.didFocusCallBack != nil {
+                        completion?(false)
+                        groupView.didFocusCallBack = nil
+                    }
+                }
+            } else {
+                completion?(true)
+            }
+        }
+    }
+}

package/apple/tvos/ReactNative/QuickBrickViewController.swift

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

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

@@ -6,13 +6,10 @@
 //  Copyright © 2019 Kononenko. All rights reserved.
 //
 
-import Combine
 import Foundation
 import React
 import UIKit
 
-/// Focusable  Group View that implements UIFocusGuide instance that catches focus event
-///
 public class FocusableGroupView: RCTTVView {
     override public var debugDescription: String {
         let groupIdDesc = groupId ?? "NO_GROUP"
@@ -35,9 +32,6 @@ public class FocusableGroupView: RCTTVView {
         """
     }
 
-    private var cancellables = Set<AnyCancellable>()
-
-    /// Completion that will be used when focus manager forcing to update focusable group
     public var didFocusCallBack: (completion: () -> Void, focusableItemId: String)?
 
     private lazy var activeStateNotifier: FocusableGroupStateNotifier = FocusableGroupStateNotifierDefault(action: notifyReactNativeFocusUpdate)
@@ -45,40 +39,38 @@ public class FocusableGroupView: RCTTVView {
     @objc public var onGroupFocus: RCTDirectEventBlock?
     @objc public var onGroupBlur: RCTDirectEventBlock?
 
-    /// Define if focus enabled for current view
     @objc public var isFocusDisabled: Bool = false
 
-    /// Current group will try to find initial index id in groups
     @objc public var dependantGroupIds: [String]?
 
-    /// Check if preferred focus environment disabled
     @objc public var isWithMemory: Bool = true
     var isPreferredFocusDisabled: Bool {
         isWithMemory == false
     }
 
-    /// ID of the Connected GroupView provided by React-Native env
     @objc public var itemId: String? {
         didSet {
             if itemId != oldValue {
-                Task(priority: .userInitiated) {
-                    await manager.registerGroup(self)
+                if oldValue != nil {
+                    proxy?.unbindGroup()
+                    proxy = nil
+                }
+
+                if let newId = itemId {
+                    proxy = GroupProxyManager.shared.getOrCreateProxy(forGroupId: newId)
+                    proxy?.bindGroup(self)
                 }
             }
         }
     }
 
-    /// ID of the parent group, if relevant
     @objc public var groupId: String?
 
     @MainActor private var userPreferredFocusEnvironments: [UIFocusEnvironment]?
     @MainActor private var customPreferredFocusEnvironment: [UIFocusEnvironment]?
 
-    private var manager: FocusableGroupManager {
-        FocusableGroupManager.shared
-    }
+    private var proxy: GroupProxy?
 
-    /// Manager that connects View instance to FocusableGroupViewModule
     private weak var module: FocusableGroupViewModule?
     public func setModule(_ module: FocusableGroupViewModule) {
         self.module = module
@@ -90,17 +82,20 @@ public class FocusableGroupView: RCTTVView {
 
     override public func removeFromSuperview() {
         super.removeFromSuperview()
+        cleanup()
+    }
+
+    deinit {
+        cleanup()
+    }
+
+    private func cleanup() {
         guard let itemId else {
             return
         }
 
-        Task {
-            // Removing when react native releases the view
-            await manager.unregisterGroup(withId: itemId)
-
-            cancellables.forEach { $0.cancel() }
-            cancellables.removeAll()
-        }
+        proxy?.unbindGroup()
+        proxy = nil
     }
 
     public required init?(coder aDecoder: NSCoder) {
@@ -120,6 +115,14 @@ public class FocusableGroupView: RCTTVView {
         customPreferredFocusEnvironment = [view]
     }
 
+    @MainActor func setUserPreferredFocusEnvironments(_ environments: [UIFocusEnvironment]?) {
+        userPreferredFocusEnvironments = environments
+    }
+
+    @MainActor func getUserPreferredFocusEnvironments() -> [UIFocusEnvironment]? {
+        userPreferredFocusEnvironments
+    }
+
     let groupFocusGuide = UIFocusGuide()
 
     private func setupFocus() {
@@ -129,27 +132,6 @@ public class FocusableGroupView: RCTTVView {
         groupFocusGuide.topAnchor.constraint(equalTo: topAnchor).isActive = true
         groupFocusGuide.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
         groupFocusGuide.rightAnchor.constraint(equalTo: rightAnchor).isActive = true
-
-        manager.focusableItemDidUpdatePreferredFocus
-            .compactMap { [weak self] focusableView -> FocusableView? in
-                guard let self,
-                      groupId != nil,
-                      focusableView.groupId == self.itemId
-                else {
-                    return nil
-                }
-                return focusableView
-            }
-            .sink { [weak self] focusableView in
-                guard let self else { return }
-
-                if focusableView.preferredFocus {
-                    userPreferredFocusEnvironments = [focusableView]
-                } else if let currentPreferred = userPreferredFocusEnvironments?.first as? FocusableView,
-                          currentPreferred == focusableView {
-                    userPreferredFocusEnvironments = nil
-                }
-            }.store(in: &cancellables)
     }
 
     private func createFocusEventParams(context: UIFocusUpdateContext, isActive: Bool) -> [String: Any] {

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

@@ -6,7 +6,6 @@
 //  Copyright © 2019 Anton Kononenko. All rights reserved.
 //
 
-import Combine
 import Foundation
 import React
 import UIKit
@@ -36,8 +35,6 @@ public class FocusableView: ParallaxView {
         """
     }
 
-    private var cancellables = Set<AnyCancellable>()
-
     private weak var module: FocusableViewModule?
     func setModule(_ module: FocusableViewModule) {
         self.module = module
@@ -58,28 +55,21 @@ public class FocusableView: ParallaxView {
         }
     }
 
-    /// Define if view can become focused
     @objc open var focusable = true
 
-    private var manager: FocusableGroupManager {
-        FocusableGroupManager.shared
-    }
-
-    @MainActor private weak var focusableGroup: FocusableGroupProtocol? {
-        didSet {
-            manager.notifyFocusableItemDidUpdatePreferredFocus(focusableView: self)
-        }
-    }
+    private var proxy: GroupProxy?
 
     @MainActor @objc public var preferredFocus: Bool = false {
         didSet {
-            manager.notifyFocusableItemDidUpdatePreferredFocus(focusableView: self)
+            if oldValue == preferredFocus {
+                return
+            }
+
+            proxy?.updatePreferredFocus(self)
         }
     }
 
     private var isFocusLayoutConfigured = false
-
-    /// Define if view was registered
     private var isViewRegistered: Bool = false
 
     override public init(frame: CGRect) {
@@ -92,31 +82,34 @@ public class FocusableView: ParallaxView {
         initialize()
     }
 
-    /// Initialize component
     private func initialize() {
         delegate = self
-
-        manager.focusableGroupRegistrationUpdates
-            .filter { $0.itemId == self.groupId }
-            .sink { [weak self] focusableGroup in
-                guard let self else { return }
-                DispatchQueue.main.async {
-                    self.focusableGroup = focusableGroup
-                }
-            }.store(in: &cancellables)
     }
 
-    /// ID of the View provided by React-Native env
     @objc private(set) var itemId: String? {
         didSet {
-            registerView()
+            if itemId != oldValue {
+                if oldValue != nil {
+                    proxy?.removeChild(self)
+                    isViewRegistered = false
+                }
+
+                registerView()
+            }
         }
     }
 
-    /// ID of the View provided by React-Native env
     @objc private(set) var groupId: String? {
         didSet {
-            registerView()
+            if groupId != oldValue {
+                if oldValue != nil {
+                    proxy?.removeChild(self)
+                    proxy = nil
+                    isViewRegistered = false
+                }
+
+                registerView()
+            }
         }
     }
 
@@ -129,35 +122,31 @@ public class FocusableView: ParallaxView {
         }
     }
 
-    /// Register View in FocusableGroupManager
     private func registerView() {
-        Task(priority: .userInitiated) {
-            guard itemId != nil,
-                  groupId != nil,
-                  isViewRegistered == false,
-                  await FocusableGroupManager.shared.registerItem(self)
-            else {
-                return
-            }
-
-            await MainActor.run {
-                isViewRegistered = true
-            }
+        guard let groupId,
+              itemId != nil,
+              isViewRegistered == false
+        else {
+            return
         }
+
+        proxy = GroupProxyManager.shared.getOrCreateProxy(forGroupId: groupId)
+        proxy?.addChild(self)
+        isViewRegistered = true
     }
 
     override public func removeFromSuperview() {
         super.removeFromSuperview()
-        guard let itemId, let groupId else {
-            return
-        }
+        cleanup()
+    }
 
-        Task {
-            await FocusableGroupManager.shared.unregisterItem(withId: itemId, inGroup: groupId)
-        }
+    deinit {
+        cleanup()
+    }
 
-        cancellables.forEach { $0.cancel() }
-        cancellables.removeAll()
+    private func cleanup() {
+        proxy?.removeChild(self)
+        proxy = nil
     }
 
     private func addFocusGuideIfNeeded(tag: NSNumber?,
@@ -226,32 +215,18 @@ public class FocusableView: ParallaxView {
             }
 
             DispatchQueue.main.async { [weak self] in
-                FocusableGroupManager.shared.updateFocus(groupId: self?.groupId,
-                                                         itemId: self?.itemId,
-                                                         needsForceUpdate: true)
+                GroupProxyManager.shared.updateFocus(groupId: self?.groupId,
+                                                     itemId: self?.itemId,
+                                                     needsForceUpdate: true)
             }
         }
     }
 
     override public var canBecomeFocused: Bool {
-        guard let focusableGroup else {
+        guard let focusableGroup = proxy?.getGroup() else {
             return focusable
         }
 
         return focusableGroup.canBecomeFocusable && focusable
     }
 }
-
-//    TODO: Example of solution for future with groupId and focuse id
-//    func hintLeftFocusId() {
-//        if let onFocusLeft = dictFromReactNative,
-//           let groupId = onFocusLeft["groupId"],
-//           let id = onFocusLeft["id"],
-//           let view = FocusableGroupManager.item(byGroupId: groupId,
-//                                                 andItemId: id) {
-//            _ = addFocusGuide(from: self,
-//                              to: view,
-//                              direction: .left,
-//                              debugMode: true)
-//        }
-//    }

package/apple/universal/ReactNative/AnalyticsBridge.swift

@@ -16,12 +16,12 @@ class AnalyticsBridge: NSObject, RCTBridgeModule {
         "AnalyticsBridge"
     }
 
-    public class func requiresMainQueueSetup() -> Bool {
+    class func requiresMainQueueSetup() -> Bool {
         true
     }
 
     /// prefered thread on which to run this native module
-    @objc public var methodQueue: DispatchQueue {
+    @objc var methodQueue: DispatchQueue {
         DispatchQueue.main
     }