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

package/apple/QuickBrickApple.podspec.json

@@ -1,6 +1,6 @@
 {
   "name": "QuickBrickApple",
-  "version": "6.16.1",
+  "version": "6.18.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.1"
+    "tag": "@@applicaster/quick-brick-native-apple/6.18.0"
   },
   "requires_arc": true,
   "source_files": "universal/**/*.{m,swift}",

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

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

@@ -7,13 +7,14 @@
 
 import Foundation
 import React
+import ZappCore
 
 class GroupProxyManager {
     static let shared = GroupProxyManager()
 
     private let lock = NSLock()
-    private var proxies: [GroupProxy] = []
-
+    private var proxies: [String: GroupProxy] = [:]
+    private var coordinator: GroupProxyCoordinator = .init()
     private init() {}
 
     // MARK: - Proxy Access
@@ -22,26 +23,89 @@ class GroupProxyManager {
         lock.lock()
         defer { lock.unlock() }
 
-        if let existing = proxies.first(where: { $0.groupId == groupId }) {
+        if let existing = proxies[groupId] {
             return existing
         }
 
-        let proxy = GroupProxy(groupId: groupId)
-        proxies.append(proxy)
+        let proxy = GroupProxy(groupId: groupId, coordinator: coordinator)
+        proxies[groupId] = proxy
         return proxy
     }
 
+    func getProxy(forGroupId groupId: String) -> GroupProxy? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        return proxies[groupId]
+    }
+
+    func hasProxy(forGroupId groupId: String) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+
+        return proxies[groupId] != nil
+    }
+
     // MARK: - Cleanup
 
     func removeProxy(forGroupId groupId: String) {
         lock.lock()
         defer { lock.unlock() }
 
-        proxies.removeAll { $0.groupId == groupId }
+        coordinator.cancelCommandsForGroup(groupId: groupId)
+        proxies.removeValue(forKey: groupId)
     }
 
     // MARK: - Focus Update
 
+    private var forceFocusUpdateData: (itemId: String, groupId: String)?
+
+    func setForceFocusUpdateData(itemId: String, groupId: String) {
+        lock.lock()
+        forceFocusUpdateData = (itemId: itemId, groupId: groupId)
+        lock.unlock()
+    }
+
+    func clearForceFocusUpdate() {
+        lock.lock()
+        forceFocusUpdateData = nil
+        lock.unlock()
+    }
+
+    func focusableViewCanBecomeFocusableForceFocusUpdate(groupId: String?, itemId: String?) -> Bool? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard let groupId,
+              let itemId,
+              let forceFocusData = forceFocusUpdateData else {
+            return nil
+        }
+
+        if groupId == forceFocusData.groupId,
+           itemId == forceFocusData.itemId {
+            return true
+        }
+
+        return false
+    }
+
+    func focusableGroupCanBecomeFocusableForceFocusUpdate(groupId: String?) -> Bool? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        guard let groupId,
+              let forceFocusData = forceFocusUpdateData else {
+            return nil
+        }
+
+        if groupId == forceFocusData.groupId {
+            return true
+        }
+
+        return false
+    }
+
     func updateFocus(groupId: String?,
                      itemId: String?,
                      needsForceUpdate: Bool = false,
@@ -52,50 +116,16 @@ class GroupProxyManager {
             return
         }
 
-        lock.lock()
-        let proxy = proxies.first(where: { $0.groupId == groupId })
-        lock.unlock()
+        coordinator.cancelCommandsForGroup(groupId: groupId)
 
-        guard let proxy,
-              let groupView = proxy.getGroup() else {
-            completion?(false)
-            return
-        }
+        let command = GroupProxyCoordinator.SetItemFocus(
+            groupId: groupId,
+            itemId: itemId,
+            needsForceUpdate: needsForceUpdate,
+            completion: completion,
+            manager: self
+        )
 
-        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)
-            }
-        }
+        coordinator.tryApply(command)
     }
 }

package/apple/tvos/ReactNativeModulesExportstvOS.m

@@ -18,6 +18,7 @@ RCT_EXTERN_METHOD(setPreferredFocus:(NSString *)groupId itemId:(NSString *)itemI
 @end
 
 @interface RCT_EXTERN_MODULE(FocusableGroupViewModule, RCTViewManager)
+RCT_EXPORT_VIEW_PROPERTY(onRegistered, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onGroupFocus, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onGroupBlur, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(itemId, NSString);
@@ -27,6 +28,7 @@ RCT_EXPORT_VIEW_PROPERTY(isFocusDisabled, BOOL);
 @end
 
 @interface RCT_EXTERN_MODULE(FocusableViewModule, RCTViewManager)
+RCT_EXPORT_VIEW_PROPERTY(onRegistered, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(itemId, NSString);
 RCT_EXPORT_VIEW_PROPERTY(groupId, NSString);
 RCT_EXPORT_VIEW_PROPERTY(forceFocus, BOOL)

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

@@ -20,10 +20,7 @@ typealias NotifierActionType = (_ type: FocusableGroupNotifierActionType, _ cont
 class FocusableGroupStateNotifierDefault: FocusableGroupStateNotifier {
     private(set) var isActive: Bool = false
 
-    let action: NotifierActionType
-    init(action: @escaping NotifierActionType) {
-        self.action = action
-    }
+    var action: NotifierActionType?
 
     func updateFocus(currentlyActive: Bool, context: UIFocusUpdateContext) {
         guard currentlyActive != isActive else { return }
@@ -33,6 +30,6 @@ class FocusableGroupStateNotifierDefault: FocusableGroupStateNotifier {
     }
 
     func sendNotifierEvent(context: UIFocusUpdateContext) {
-        action(isActive ? .onFocus : .onBlur, context)
+        action?(isActive ? .onFocus : .onBlur, context)
     }
 }

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

@@ -19,6 +19,7 @@ public class FocusableGroupView: RCTTVView {
         let preferredFocusDisabledDesc = isPreferredFocusDisabled ? "preferred-focus-disabled" : "preferred-focus-enabled"
         let dependentGroupsDesc = dependantGroupIds?.joined(separator: ",") ?? "NO_DEPS"
         let reactTagDesc = reactTag?.stringValue ?? "NO_TAG"
+        let preferredFocusEnvDesc = preferredFocusEnvironments.first.map { String(describing: $0) } ?? "N/A"
 
         return """
         FocusableGroupView[
@@ -28,16 +29,58 @@ public class FocusableGroupView: RCTTVView {
             STATE: \(activeStateDesc), \(focusDisabledDesc), \(preferredFocusDisabledDesc)
             DEPS: \(dependentGroupsDesc)
             FRAME: \(frame)
+            PREFFERED_FOCUS_ENVIRONMENTS: \(preferredFocusEnvDesc)
         ]
         """
     }
 
-    public var didFocusCallBack: (completion: () -> Void, focusableItemId: String)?
+    public private(set) var isPresented: Bool = false
+    private var focusTimer: Timer?
 
-    private lazy var activeStateNotifier: FocusableGroupStateNotifier = FocusableGroupStateNotifierDefault(action: notifyReactNativeFocusUpdate)
+    override public func didMoveToWindow() {
+        super.didMoveToWindow()
+        updateIsPresented()
+    }
+
+    override public func layoutSubviews() {
+        super.layoutSubviews()
+        updateIsPresented()
+    }
+
+    private func updateIsPresented() {
+        isPresented =
+            window != nil &&
+            bounds.width > 0 &&
+            bounds.height > 0 &&
+            !isHidden &&
+            alpha > 0.01
+        registerGroup()
+    }
+
+    private func registerGroup() {
+        guard let itemId,
+              isPresented,
+              isGroupRegistered == false
+        else {
+            return
+        }
+
+        activeStateNotifier.action = { [weak self] type, context in
+            self?.notifyReactNativeFocusUpdate(type, context)
+        }
+
+        proxy = GroupProxyManager.shared.getOrCreateProxy(forGroupId: itemId)
+        proxy?.bindGroup(self)
+        isGroupRegistered = true
+    }
+
+    public var didForceFocusCallBack: ((Bool) -> Void)?
+
+    private let activeStateNotifier = FocusableGroupStateNotifierDefault()
 
     @objc public var onGroupFocus: RCTDirectEventBlock?
     @objc public var onGroupBlur: RCTDirectEventBlock?
+    @objc public var onRegistered: RCTDirectEventBlock?
 
     @objc public var isFocusDisabled: Bool = false
 
@@ -48,24 +91,33 @@ public class FocusableGroupView: RCTTVView {
         isWithMemory == false
     }
 
+    private var isGroupRegistered: Bool = false
+
     @objc public var itemId: String? {
         didSet {
             if itemId != oldValue {
                 if oldValue != nil {
-                    proxy?.unbindGroup()
+                    proxy?.unbindGroup(expectedGroup: self)
                     proxy = nil
+                    isGroupRegistered = false
                 }
 
-                if let newId = itemId {
-                    proxy = GroupProxyManager.shared.getOrCreateProxy(forGroupId: newId)
-                    proxy?.bindGroup(self)
-                }
+                registerGroup()
             }
         }
     }
 
     @objc public var groupId: String?
 
+    func sendGroupRegisteredEvent() {
+        var params: [String: Any] = [:]
+        params[GroupViewUpdateEvents.preferredFocusEnvironment] = dataForFocusItem(focusItem: preferredFocusEnvironments.first)
+        params[GroupViewUpdateEvents.groupId] = groupId
+        params[GroupViewUpdateEvents.isFocusDisabled] = isFocusDisabled
+        params[GroupViewUpdateEvents.itemId] = itemId
+        onRegistered?(params)
+    }
+
     @MainActor private var userPreferredFocusEnvironments: [UIFocusEnvironment]?
     @MainActor private var customPreferredFocusEnvironment: [UIFocusEnvironment]?
 
@@ -86,16 +138,79 @@ public class FocusableGroupView: RCTTVView {
     }
 
     deinit {
+        focusTimer?.invalidate()
+        focusTimer = nil
         cleanup()
     }
 
+    @MainActor public func forceFocus(view: FocusableView,
+                                      needsForceUpdate: Bool,
+                                      callback completion: ((Bool) -> Void)?) {
+        updatePreferredFocusEnv(with: view)
+
+        if !needsForceUpdate {
+            completion?(true)
+            return
+        }
+
+        guard let rootView = UIApplication.shared.rootViewController()?.view as? RCTRootView else {
+            completion?(false)
+            return
+        }
+
+        guard itemId != nil else {
+            completion?(false)
+            return
+        }
+
+        focusTimer?.invalidate()
+        focusTimer = nil
+
+        didForceFocusCallBack = { [weak self] success in
+            guard let self else {
+                completion?(false)
+                return
+            }
+
+            focusTimer?.invalidate()
+            focusTimer = nil
+
+            completion?(success)
+            didForceFocusCallBack = nil
+        }
+
+        let cancelationTimeout: TimeInterval = 1
+        focusTimer?.invalidate()
+        focusTimer = Timer.scheduledTimer(withTimeInterval: cancelationTimeout, repeats: false) { [weak self] _ in
+            guard let self else {
+                completion?(false)
+                return
+            }
+
+            if let callback = didForceFocusCallBack {
+                callback(false)
+                didForceFocusCallBack = nil
+            }
+
+            focusTimer = nil
+        }
+
+        rootView.setNeedsFocusUpdate()
+        rootView.updateFocusIfNeeded()
+    }
+
     private func cleanup() {
-        guard let itemId else {
+        guard itemId != nil else {
             return
         }
 
-        proxy?.unbindGroup()
+        activeStateNotifier.action = nil
+        customPreferredFocusEnvironment = nil
+        userPreferredFocusEnvironments = nil
+
+        proxy?.unbindGroup(expectedGroup: self)
         proxy = nil
+        isGroupRegistered = false
     }
 
     public required init?(coder aDecoder: NSCoder) {
@@ -234,7 +349,9 @@ public class FocusableGroupView: RCTTVView {
     // MARK: Focus Engine
 
     override public var preferredFocusEnvironments: [UIFocusEnvironment] {
-        customPreferredFocusEnvironment ?? userPreferredFocusEnvironments ?? super.preferredFocusEnvironments
+        customPreferredFocusEnvironment ??
+            userPreferredFocusEnvironments ??
+            super.preferredFocusEnvironments
     }
 
     override public func shouldUpdateFocus(in _: UIFocusUpdateContext) -> Bool {
@@ -248,36 +365,19 @@ public class FocusableGroupView: RCTTVView {
             updatePreferredFocusView(nextFocusItem: context.nextFocusedItem)
         }
 
+        didForceFocusCallBack?(true)
+
         let isActive = focusItemIsDescendant(nextFocusItem: context.nextFocusedItem)
         activeStateNotifier.updateFocus(currentlyActive: isActive, context: context)
-
-        tryDidFocusCallCallback(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.
-    private func tryDidFocusCallCallback(context: UIFocusUpdateContext) {
-        guard let callbackData = didFocusCallBack,
-              let fousedView = context.nextFocusedView as? FocusableView,
-              let itemId = fousedView.itemId
-        else {
-            return
-        }
-
-        let completion = callbackData.completion
-        let focusableItemId = callbackData.focusableItemId
-        if itemId == focusableItemId {
-            DispatchQueue.main.asyncAfter(deadline: .now()) {
-                completion()
-            }
-        }
-        didFocusCallBack = nil
     }
 }
 
 extension FocusableGroupView: FocusableGroupProtocol {
     var canBecomeFocusable: Bool {
-        !isFocusDisabled
+        if let forceFocusEnabled = GroupProxyManager.shared.focusableGroupCanBecomeFocusableForceFocusUpdate(groupId: itemId) {
+            return forceFocusEnabled
+        }
+
+        return !isFocusDisabled
     }
 }

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

@@ -35,6 +35,32 @@ public class FocusableView: ParallaxView {
         """
     }
 
+    public private(set) var isPresented: Bool = false
+    @objc public var onRegistered: RCTDirectEventBlock?
+
+    func sendViewRegisteredEvent() {
+        var params: [String: Any] = [:]
+        params[GroupViewUpdateEvents.groupId] = groupId
+        params[GroupViewUpdateEvents.isFocusDisabled] = !canBecomeFocused
+        params[GroupViewUpdateEvents.itemId] = itemId
+        onRegistered?(params)
+    }
+
+    override public func didMoveToWindow() {
+        super.didMoveToWindow()
+        updateIsPresented()
+    }
+
+    private func updateIsPresented() {
+        isPresented =
+            window != nil &&
+            bounds.width > 0 &&
+            bounds.height > 0 &&
+            !isHidden &&
+            alpha > 0.01
+        registerView()
+    }
+
     private weak var module: FocusableViewModule?
     func setModule(_ module: FocusableViewModule) {
         self.module = module
@@ -115,7 +141,7 @@ public class FocusableView: ParallaxView {
 
     override public func layoutSubviews() {
         super.layoutSubviews()
-
+        updateIsPresented()
         if isFocusLayoutConfigured == false {
             configureFocusLayout()
             isFocusLayoutConfigured = true
@@ -125,6 +151,7 @@ public class FocusableView: ParallaxView {
     private func registerView() {
         guard let groupId,
               itemId != nil,
+              isPresented,
               isViewRegistered == false
         else {
             return
@@ -227,6 +254,10 @@ public class FocusableView: ParallaxView {
             return focusable
         }
 
+        if let forceFocusEnabled = GroupProxyManager.shared.focusableViewCanBecomeFocusableForceFocusUpdate(groupId: groupId, itemId: itemId) {
+            return forceFocusEnabled
+        }
+
         return focusableGroup.canBecomeFocusable && focusable
     }
 }

package/apple/universal/ReactNative/ContextResolverBridge.swift

@@ -0,0 +1,77 @@
+//
+//  ContextResolverBridge.swift
+//  QuickBrickApple
+//
+//  Created by Alex Zchut on 15/01/2026.
+//  Copyright © 2026 Applicaster LTD. All rights reserved.
+//
+
+import Foundation
+import React
+import ZappCore
+
+@objc(ContextResolverBridge)
+class ContextResolverBridge: NSObject, RCTBridgeModule {
+    static func moduleName() -> String! {
+        "ContextResolverBridge"
+    }
+
+    class func requiresMainQueueSetup() -> Bool {
+        true
+    }
+
+    /// prefered thread on which to run this native module
+    @objc var methodQueue: DispatchQueue {
+        DispatchQueue.main
+    }
+
+    @objc func resolveContextKeys(_ keys: [String: Any],
+                                  resolver: @escaping RCTPromiseResolveBlock,
+                                  rejecter _: @escaping RCTPromiseRejectBlock) {
+        var result: [String: Any] = [:]
+
+        for (key, value) in keys {
+            let isRequired = extractBoolValue(from: value)
+            let resolved = resolveStorage(key: key, required: isRequired)
+            result[key] = resolved ?? NSNull()
+        }
+
+        resolver(result)
+    }
+
+    private func extractBoolValue(from value: Any) -> Bool {
+        if let number = value as? NSNumber {
+            number.boolValue
+        } else if let boolValue = value as? Bool {
+            boolValue
+        } else {
+            false
+        }
+    }
+
+    private func resolveStorage(key: String, required _: Bool) -> String? {
+        let data = key.split(separator: ".", maxSplits: 1)
+        let (namespace, storageKey): (String?, String) = {
+            switch data.count {
+            case 2:
+                let namespace = String(data.first ?? "")
+                let storageKey = String(data.last ?? "")
+                return (namespace.isEmpty ? nil : namespace, storageKey)
+            default:
+                return (nil, key)
+            }
+        }()
+
+        if let value = FacadeConnector.connector?.storage?.sessionStorageValue(for: storageKey,
+                                                                               namespace: namespace) {
+            return value
+        }
+
+        if let value = FacadeConnector.connector?.storage?.localStorageValue(for: storageKey,
+                                                                             namespace: namespace) {
+            return value
+        }
+
+        return nil
+    }
+}

package/apple/universal/ReactNative/ReactNativeModulesExports.m

@@ -30,7 +30,7 @@ RCT_EXTERN_METHOD(setAppLanguage:(NSString *)language
 
 @interface RCT_EXTERN_MODULE (AnalyticsBridge, NSObject)
 RCT_EXTERN_METHOD(postEvent:(NSString *)event
-                     payload:(NSDictionary *)payload);
+                      payload:(NSDictionary *)payload);
 RCT_EXTERN_METHOD(postTimedEvent:(NSString *)event
                       payload:(NSDictionary *)payload);
 RCT_EXTERN_METHOD(endTimedEvent:(NSString *)event
@@ -151,18 +151,24 @@ RCT_EXTERN_METHOD(switchLayout:(NSString *)layoutId
                               rejecter:(RCTPromiseRejectBlock)reject);
 
 RCT_EXTERN_METHOD(getCurrentLayoutId:(RCTPromiseResolveBlock)resolve
-                        rejecter:(RCTPromiseRejectBlock)reject);
+                      rejecter:(RCTPromiseRejectBlock)reject);
 
 RCT_EXTERN_METHOD(getDefaultLayoutId:(RCTPromiseResolveBlock)resolve
-                        rejecter:(RCTPromiseRejectBlock)reject);
+                      rejecter:(RCTPromiseRejectBlock)reject);
 @end
 
-@interface RCT_EXTERN_MODULE(AirPlayButtonModule, RCTViewManager)
+@interface RCT_EXTERN_MODULE (AirPlayButtonModule, RCTViewManager)
 RCT_EXPORT_VIEW_PROPERTY(tintColor, UIColor);
 RCT_EXPORT_VIEW_PROPERTY(activeTintColor, UIColor);
- 
+
 @end
 
 @interface RCT_EXTERN_MODULE (ReactNativeEventBusBridge, NSObject)
 RCT_EXTERN_METHOD(postEvent:(NSDictionary *)event);
 @end
+
+@interface RCT_EXTERN_MODULE (ContextResolverBridge, NSObject)
+RCT_EXTERN_METHOD(resolveContextKeys:(NSDictionary *)keys
+                      resolver:(RCTPromiseResolveBlock)resolver
+                          rejecter:(RCTPromiseRejectBlock)rejecter);
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-native-apple",
-  "version": "6.16.1",
+  "version": "6.18.0",
   "description": "iOS and tvOS native code for QuickBrick applications. This package is used to provide native logic for QuickBrick",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"