@applicaster/quick-brick-native-apple 6.16.0 → 6.17.0

package/apple/QuickBrickApple.podspec.json

@@ -1,6 +1,6 @@
 {
   "name": "QuickBrickApple",
-  "version": "6.16.0",
+  "version": "6.17.0",
   "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.16.0"
+    "tag": "@@applicaster/quick-brick-native-apple/6.17.0"
   },
   "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/Coordinator/GroupProxyCoordinator.swift

@@ -0,0 +1,70 @@
+//
+//  GroupProxyCoordinator.swift
+//  QuickBrickApple
+//
+//  Created by Anton Kononenko on 12/22/25.
+//
+
+import Foundation
+import React
+
+class GroupProxyCoordinator {
+    private var commandsQueue: [Command] = []
+    private let lock = NSLock()
+
+    protocol Command {
+        var groupId: String { get }
+        func canBeApplied() -> Bool
+        func apply()
+        func cancel()
+    }
+
+    func tryApply(_ command: Command) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if command.canBeApplied() {
+            command.apply()
+        } else {
+            commandsQueue.append(command)
+        }
+    }
+
+    private func processQueue() {
+        lock.lock()
+        let commands = commandsQueue
+        commandsQueue.removeAll()
+        lock.unlock()
+
+        for command in commands {
+            if command.canBeApplied() {
+                command.apply()
+            } else {
+                lock.lock()
+                commandsQueue.append(command)
+                lock.unlock()
+            }
+        }
+    }
+
+    func onGroupBound(groupId _: String) {
+        processQueue()
+    }
+
+    func onChildAdded(groupId _: String, itemId _: String) {
+        processQueue()
+    }
+
+    func cancelCommandsForGroup(groupId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        commandsQueue.removeAll { command in
+            if command.groupId == groupId {
+                command.cancel()
+                return true
+            }
+            return false
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+//
+//  SetItemFocus.swift
+//  QuickBrickApple
+//
+//  Created by Anton Kononenko on 12/22/25.
+//
+
+import Foundation
+import UIKit
+
+extension GroupProxyCoordinator {
+    class SetItemFocus: Command {
+        let groupId: String
+        let itemId: String
+        let needsForceUpdate: Bool
+        let completion: ((Bool) -> Void)?
+        weak var manager: GroupProxyManager?
+        private var isCancelled = false
+        private let lock = NSLock()
+
+        init(groupId: String,
+             itemId: String,
+             needsForceUpdate: Bool,
+             completion: ((Bool) -> Void)?,
+             manager: GroupProxyManager) {
+            self.groupId = groupId
+            self.itemId = itemId
+            self.needsForceUpdate = needsForceUpdate
+            self.completion = completion
+            self.manager = manager
+        }
+
+        func canBeApplied() -> Bool {
+            lock.lock()
+            defer { lock.unlock() }
+
+            if isCancelled {
+                return false
+            }
+
+            guard let manager,
+                  let proxy = manager.getProxy(forGroupId: groupId),
+                  let group = proxy.getGroup() else {
+                return false
+            }
+
+            if group.isFocusDisabled {
+                return false
+            }
+
+            if !proxy.isExistingChild(itemId) {
+                return false
+            }
+
+            guard let focusableView = proxy.getChild(by: itemId) else {
+                return false
+            }
+
+            if focusableView.window == nil || focusableView.frame.isEmpty {
+                return false
+            }
+
+            return true
+        }
+
+        func apply() {
+            lock.lock()
+            if isCancelled {
+                lock.unlock()
+                completion?(false)
+                return
+            }
+            lock.unlock()
+
+            guard let manager,
+                  let proxy = manager.getProxy(forGroupId: groupId),
+                  let groupView = proxy.getGroup(),
+                  let focusableView = proxy.getChild(by: itemId) else {
+                completion?(false)
+                return
+            }
+
+            manager.setForceFocusUpdateData(itemId: itemId, groupId: groupId)
+
+            DispatchQueue.main.async { [weak manager] in
+                groupView.forceFocus(
+                    view: focusableView,
+                    needsForceUpdate: self.needsForceUpdate,
+                    callback: { success in
+                        manager?.clearForceFocusUpdate()
+                        self.completion?(success)
+                    }
+                )
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            isCancelled = true
+            lock.unlock()
+
+            completion?(false)
+        }
+    }
+}

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

@@ -0,0 +1,90 @@
+//
+//  SetPreferredFocus.swift
+//  QuickBrickApple
+//
+//  Created by Anton Kononenko on 12/23/25.
+//
+
+import Foundation
+import UIKit
+
+extension GroupProxyCoordinator {
+    class SetPreferredFocus: Command {
+        let groupId: String
+        let itemId: String
+        let isPreferred: Bool
+        weak var manager: GroupProxyManager?
+        private var isCancelled = false
+        private let lock = NSLock()
+
+        init(groupId: String,
+             itemId: String,
+             isPreferred: Bool,
+             manager: GroupProxyManager) {
+            self.groupId = groupId
+            self.itemId = itemId
+            self.isPreferred = isPreferred
+            self.manager = manager
+        }
+
+        func canBeApplied() -> Bool {
+            lock.lock()
+            defer { lock.unlock() }
+
+            if isCancelled {
+                return false
+            }
+
+            guard let manager,
+                  let proxy = manager.getProxy(forGroupId: groupId),
+                  let group = proxy.getGroup() else {
+                return false
+            }
+
+            if !proxy.isExistingChild(itemId) {
+                return false
+            }
+
+            guard let focusableView = proxy.getChild(by: itemId) else {
+                return false
+            }
+
+            if focusableView.window == nil || focusableView.frame.isEmpty {
+                return false
+            }
+
+            return true
+        }
+
+        func apply() {
+            lock.lock()
+            if isCancelled {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+
+            guard let manager,
+                  let proxy = manager.getProxy(forGroupId: groupId),
+                  let group = proxy.getGroup(),
+                  let focusableView = proxy.getChild(by: itemId) else {
+                return
+            }
+
+            DispatchQueue.main.async {
+                if self.isPreferred {
+                    group.setUserPreferredFocusEnvironments([focusableView])
+                } else if let currentPreferred = group.getUserPreferredFocusEnvironments()?.first as? FocusableView,
+                          currentPreferred === focusableView {
+                    group.setUserPreferredFocusEnvironments(nil)
+                }
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            isCancelled = true
+            lock.unlock()
+        }
+    }
+}

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

@@ -15,7 +15,7 @@ let kFocusableManagerModule = "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
+    var delayTimer = 0
 
     /// main React bridge
     var bridge: RCTBridge?
@@ -58,7 +58,6 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
     @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) {
             GroupProxyManager.shared.updateFocus(groupId: groupId,
                                                  itemId: itemId,

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

@@ -11,50 +11,80 @@ import XrayLogger
 class GroupProxy {
     let groupId: String
     private weak var group: FocusableGroupView?
-    private var children: [WeakBox<FocusableView>] = []
+    private weak var coordinator: GroupProxyCoordinator?
+    private var children: [String: WeakBox<FocusableView>] = [:]
     private let lock = NSLock()
 
-    var delayedPreferredFocus: FocusableView?
-
     private lazy var logger = Logger.getLogger(for: "QuickBrickApple/FocusableGroupManager/GroupProxy")
 
-    init(groupId: String) {
+    init(groupId: String, coordinator: GroupProxyCoordinator) {
         self.groupId = groupId
+        self.coordinator = coordinator
+    }
+
+    func getChild(by itemId: String) -> FocusableView? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        return children[itemId]?.value
     }
 
     // MARK: - Child Management
 
     func addChild(_ view: FocusableView) {
         lock.lock()
-        children.append(WeakBox(view))
+
+        guard let itemId = view.itemId else {
+            lock.unlock()
+            return
+        }
+
+        children[itemId] = WeakBox(view)
         lock.unlock()
+
+        view.sendViewRegisteredEvent()
+
+        coordinator?.onChildAdded(groupId: groupId, itemId: itemId)
     }
 
     func removeChild(_ view: FocusableView) {
         lock.lock()
-        defer { lock.unlock() }
 
-        children.removeAll { $0.value === view }
+        if let itemId = view.itemId {
+            children.removeValue(forKey: itemId)
+        }
 
-        if children.isEmpty, group == nil {
+        let shouldRemoveProxy = children.isEmpty && group == nil
+        lock.unlock()
+
+        if shouldRemoveProxy {
+            coordinator?.cancelCommandsForGroup(groupId: groupId)
             GroupProxyManager.shared.removeProxy(forGroupId: groupId)
         }
+    }
 
-        if delayedPreferredFocus === view {
-            delayedPreferredFocus = nil
-        }
+    func isExistingChild(_ itemId: String) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return children[itemId]?.value != nil
     }
 
     // MARK: - Group Binding
 
     @MainActor func bindGroup(_ group: FocusableGroupView) {
-        // Check for duplicate group binding
-        if let existingGroup = self.group {
+        lock.lock()
+        let existingGroup = self.group
+        lock.unlock()
+
+        if let existingGroup, existingGroup !== group {
             logger?.warningLog(message: """
             ⚠️ Duplicate group binding detected for groupId: '\(groupId)'
                Previous group: \(existingGroup.debugDescription)
                New group: \(group.debugDescription)
-               Overwriting previous binding.
+                identifier1: \(ObjectIdentifier(existingGroup))
+                identifier2: \(ObjectIdentifier(group))
+               Previous group will be unable to unbind (React Native created duplicate itemIds).
+               Old group's cleanup() will handle releasing its proxy reference.
             """)
 
             #if DEBUG
@@ -62,53 +92,63 @@ class GroupProxy {
             #endif
         }
 
+        lock.lock()
         self.group = group
+        lock.unlock()
 
-        if let preferredFocusView = delayedPreferredFocus {
-            applyPreferredFocus(group,
-                                view: preferredFocusView)
-            delayedPreferredFocus = nil
-        }
+        group.sendGroupRegisteredEvent()
+
+        coordinator?.onGroupBound(groupId: groupId)
     }
 
-    func unbindGroup() {
+    func unbindGroup(expectedGroup: FocusableGroupView) {
+        if let group,
+           group !== expectedGroup {
+            logger?.warningLog(message: """
+            ⚠️ Mismatched group unbinding detected for groupId: '\(groupId)'
+                Expected group: \(expectedGroup.debugDescription)
+                Current bound group: \(String(describing: group.debugDescription))
+                identifier1: \(ObjectIdentifier(expectedGroup))
+                identifier2: \(ObjectIdentifier(group)))
+                Skipping unbind.
+            """)
+
+            return
+        }
+
         lock.lock()
-        defer { lock.unlock() }
+        let shouldRemoveProxy = children.isEmpty
+        lock.unlock()
 
-        if children.isEmpty {
+        if shouldRemoveProxy {
+            coordinator?.cancelCommandsForGroup(groupId: groupId)
             GroupProxyManager.shared.removeProxy(forGroupId: groupId)
         }
 
+        lock.lock()
         group = nil
+        lock.unlock()
     }
 
     // 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) {
+        guard let itemId = view.itemId else {
+            return
         }
-    }
 
-    @MainActor func updatePreferredFocus(_ view: FocusableView) {
-        lock.lock()
-        let currentGroup = group
-        lock.unlock()
+        coordinator?.cancelCommandsForGroup(groupId: groupId)
 
-        if let currentGroup {
-            applyPreferredFocus(currentGroup,
-                                view: view)
-        } else {
-            if view.preferredFocus {
-                delayedPreferredFocus = view
-            }
-        }
+        let command = GroupProxyCoordinator.SetPreferredFocus(
+            groupId: groupId,
+            itemId: itemId,
+            isPreferred: view.preferredFocus,
+            manager: GroupProxyManager.shared
+        )
+
+        coordinator?.tryApply(command)
     }
 
-    /// Get the bound group (if any)
     func getGroup() -> FocusableGroupView? {
         lock.lock()
         defer { lock.unlock() }