@applicaster/quick-brick-native-apple 6.9.4 → 6.9.5

package/apple/QuickBrickApple.podspec.json

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

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

@@ -6,109 +6,92 @@
 //  Copyright © 2019 Anton Kononenko. All rights reserved.
 //
 
+import Combine
 import Foundation
 import React
 
-/// Storage for focusable groups view [GroupID:FocusableGroupViewInstance]
-var focusableGroups: [String: FocusableGroupView] = [:]
-
-/// Storage for focusable views [GroupID:[ViewID:FocusableViewIntance]]
-var itemsGroups: [String: [String: FocusableView]] = [:]
+protocol FocusableGroupManagerUpdater {
+    var focusableGroupRegistrationUpdates: PassthroughSubject<FocusableGroupView, Never> { get }
+    var focusableItemsUpdatedAddedToGroupUpdate: PassthroughSubject<FocusableGroupUpdateEvent, Never> { get }
+}
 
 /// Class control focusable group view with focusable items
 class FocusableGroupManager {
-    /// Register FocusableView at storage
-    ///
-    /// - Parameter item: FocusableView instance
-    class func registerView(item: FocusableView) -> Bool {
-        guard let itemId = item.itemId,
-              let groupId = item.groupId
-        else {
+    static let shared = FocusableGroupManager()
+
+    private let groupStorage: FocusableGroupStorage
+    private let itemStorage: FocusableItemStorage
+    private let updateService: UpdateService
+
+    private init(groupStorage: FocusableGroupStorage = InMemoryFocusableGroupStorage(),
+                 itemStorage: FocusableItemStorage = InMemoryFocusableItemStorage(),
+                 updateService: UpdateService = UpdateService()) {
+        self.groupStorage = groupStorage
+        self.itemStorage = itemStorage
+        self.updateService = updateService
+    }
+
+    // MARK: - Group Managment
+
+    public func registerGroup(_ group: FocusableGroupView) async -> Bool {
+        let wasRegistered = await groupStorage.registerGroup(group)
+        guard wasRegistered else {
             return false
         }
-        var newItemsGroup: [String: FocusableView] = [:]
-        if let itemsGroup = itemsGroups[groupId] {
-            newItemsGroup = itemsGroup
-        }
 
-        newItemsGroup[itemId] = item
-        itemsGroups[groupId] = newItemsGroup
-        notifyGroupView(groupID: groupId)
+        updateService.sendFocusableGroupRegisteredUpdate(group)
         return true
     }
 
-    class func unregisterFusableItem(itemId: String, groupId: String) {
-        var newItemsGroup: [String: FocusableView] = [:]
-        if let itemsGroup = itemsGroups[groupId] {
-            newItemsGroup = itemsGroup
+    public func unregisterGroup(withId groupId: String) async {
+        await groupStorage.unregisterGroup(withId: groupId)
+        let items = await itemStorage.items(forGroup: groupId)
+        for itemId in items.keys {
+            await itemStorage.unregisterItem(withId: itemId, inGroup: groupId)
         }
 
-        newItemsGroup[itemId] = nil
-        itemsGroups[groupId] = newItemsGroup
+        await notifyGroupView(groupId: groupId)
     }
 
-    class func unregisterFusableGroup(itemId: String) {
-        itemsGroups[itemId] = nil
-        focusableGroups[itemId] = nil
+    public func getGroup(by groupID: String) async -> FocusableGroupView? {
+        await groupStorage.group(by: groupID)
     }
 
-    /// Register FocusableGroup at storage
-    ///
-    /// - Parameter item: FocusableGroup instance
-    class func registerFocusableGroup(group: FocusableGroupView) -> Bool {
-        var retVal = false
+    // MARK: - Item Management
 
-        if let id = group.itemId {
-            focusableGroups[id] = group
-            retVal = true
+    public func registerItem(_ item: FocusableView) async -> Bool {
+        let success = await itemStorage.registerItem(item)
+        if success,
+           let groupId = await item.groupId {
+            await notifyGroupView(groupId: groupId)
+            if let itemGroup = await getGroup(by: groupId) {
+                // Handler in case group was registerd later then items
+                updateService.sendFocusableGroupRegisteredUpdate(itemGroup)
+            }
         }
-        return retVal
+        return success
     }
 
-    /// Retrieve group by ID
-    ///
-    /// - Parameter groupID:  ID of the group
-    /// - Returns: FocusableGroupView instance if registered into manager
-    class func group(by groupID: String) -> FocusableGroupView? {
-        guard let groupView = focusableGroups[groupID] else {
-            return nil
-        }
-        return groupView
+    public func unregisterItem(withId itemId: String, inGroup groupId: String) async {
+        await itemStorage.unregisterItem(withId: itemId, inGroup: groupId)
+        await notifyGroupView(groupId: groupId)
     }
 
-    /// Retrieve All items that connected to Group
-    ///
-    /// - Parameter groupID: ID of the group
-    /// - Returns: Dictionary in format [ViewID:FocusableViewIntance]
-    class func itemsForGroup(by groupID: String) -> [String: FocusableView] {
-        guard let groupViewsDict = itemsGroups[groupID] else {
-            return [:]
-        }
-        return groupViewsDict
+    public func getItems(forGroup groupId: String) async -> [String: FocusableView] {
+        await itemStorage.items(forGroup: groupId)
     }
 
-    /// Notify group view that item relevant to it was updated
-    ///
-    /// - Parameter groupID: ID of the group
-    class func notifyGroupView(groupID: String) {
-        DispatchQueue.main.async {
-            guard let groupView = focusableGroups[groupID] else {
-                return
-            }
-            let groupItems = itemsForGroup(by: groupID)
-            groupView.groupItemsUpdated(groupItems: groupItems)
-        }
+    public func getItem(withId itemId: String, inGroup groupId: String) async -> FocusableView? {
+        await itemStorage.item(withId: itemId, inGroup: groupId)
     }
 
-    /// Retrieve FocusableView view instance
+    /// Notify group view that item relevant to it was updated
     ///
-    /// - Parameters:
-    ///   - groupId: Id of the group
-    ///   - itemId: Id of the FocusableView to search
-    /// - Returns: FocusableView instance if exist in searched group, otherwise nil
-    class func item(byGroupId groupId: String,
-                    andItemId itemId: String) -> FocusableView? {
-        itemsForGroup(by: groupId).first(where: { $0.key == itemId })?.value
+    /// - Parameter groupID: ID of the group
+    private func notifyGroupView(groupId: String) async {
+        let groupItems = await getItems(forGroup: groupId)
+        updateService.sendFocusableItemInGroupUpdate(groupId: groupId,
+                                                     focusableItems: groupItems)
     }
 
     /// Make focus item focusable if exists and registered
@@ -118,53 +101,71 @@ class FocusableGroupManager {
     ///   - itemId: Id of the focusable item
     ///   - needsForceUpdate: if value is true after make item as preferred item focus, It will also request Focus Engine to focus immidiately
     ///   - completion: completion block in case need, that will be called when focusable item did focus
-    class func updateFocus(_ groupId: String?, itemId: String?, needsForceUpdate: Bool = false, completion: ((_ success: Bool) -> Void)? = nil) {
-        DispatchQueue.main.async {
-            if let groupId,
-               let itemId,
-               let groupView = focusableGroups[groupId],
-               let viewToFocus = FocusableGroupManager.item(byGroupId: groupId,
-                                                            andItemId: itemId) {
-                groupView.updatePrefferedFocusEnv(with: viewToFocus)
-
-                var rootView: UIView? = groupView
-                while rootView !== nil, rootView?.isReactRootView() == false {
-                    if let unwrapedRootView = rootView,
-                       let superView = unwrapedRootView.superview {
-                        rootView = superView
-                    } else {
-                        rootView = nil
-                    }
-                }
+    public func updateFocus(groupId: String?,
+                            itemId: String?,
+                            needsForceUpdate: Bool = false,
+                            completion: ((Bool) -> Void)? = nil) {
+        Task { @MainActor in
+            guard
+                let groupId,
+                let itemId,
+                let groupView = await groupStorage.group(by: groupId),
+                let viewToFocus = await itemStorage.item(withId: itemId, inGroup: groupId)
+            else {
+                completion?(false)
+                return
+            }
 
-                if rootView == nil {
-                    return
-                }
+            groupView.updatePreferredFocusEnv(with: viewToFocus)
+
+            var rootView: UIView? = groupView
+
+            while rootView != nil,
+                  !rootView?.isReactRootView() {
+                rootView = rootView?.superview
+            }
+
+            guard let rootViewUnwrapped = rootView,
+                  let superView = rootViewUnwrapped.superview as? RCTRootView else {
+                completion?(false)
+                return
+            }
+
+            superView.reactPreferredFocusedView = viewToFocus
+
+            if needsForceUpdate {
+                superView.setNeedsFocusUpdate()
+                superView.updateFocusIfNeeded()
+
+                let timeout: TimeInterval = 2.0
+
+                groupView.didFocusCallBack = (completion: {
+                    completion?(true)
+                    groupView.didFocusCallBack = nil
+
+                }, focusableItemId: itemId)
 
-                if let rootView,
-                   let superView = rootView.superview as? RCTRootView {
-                    superView.reactPreferredFocusedView = viewToFocus
-                    if needsForceUpdate == true {
-                        superView.setNeedsFocusUpdate()
-                        superView.updateFocusIfNeeded()
-                        var completionWasCalled = false
-
-                        // Timeout 2 seconds if did focus was not called by some reason, we are passing completion
-                        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
-                            if completionWasCalled == false {
-                                completion?(false)
-                                groupView.didFocusCallBack = nil
-                            }
-                        }
-
-                        groupView.didFocusCallBack = (completion: {
-                            completionWasCalled = true
-                            completion?(true)
-
-                        }, focusableItemId: itemId)
+                // Timeout handling
+                Task {
+                    try? await Task.sleep(nanoseconds: UInt64(timeout * 1_000_000_000))
+                    if groupView.didFocusCallBack != nil {
+                        completion?(false)
+                        groupView.didFocusCallBack = nil
                     }
                 }
+            } else {
+                completion?(true)
             }
         }
     }
 }
+
+extension FocusableGroupManager: FocusableGroupManagerUpdater {
+    var focusableGroupRegistrationUpdates: PassthroughSubject<FocusableGroupView, Never> {
+        updateService.focusableGroupRegistrationUpdates
+    }
+
+    var focusableItemsUpdatedAddedToGroupUpdate: PassthroughSubject<FocusableGroupUpdateEvent, Never> {
+        updateService.focusableItemsUpdatedAddedToGroupUpdate
+    }
+}

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.updateFocus(groupId,
-                                              itemId: itemId)
+            FocusableGroupManager.shared.updateFocus(groupId: groupId,
+                                                     itemId: itemId)
         }
     }
 
@@ -60,12 +60,13 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
 
         DispatchQueue.main.asyncAfter(deadline: delay) {
-            FocusableGroupManager.updateFocus(groupId,
-                                              itemId: itemId,
-                                              needsForceUpdate: true, completion: { succeed in
-                                                  callback?([succeed])
+            FocusableGroupManager.shared.updateFocus(groupId: groupId,
+                                                     itemId: itemId,
+                                                     needsForceUpdate: true,
+                                                     completion: { succeed in
+                                                         callback?([succeed])
 
-                                              })
+                                                     })
         }
     }
 }

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

@@ -0,0 +1,37 @@
+//
+//  InMemoryFocusableItemStorage.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 10/28/24.
+//
+
+actor InMemoryFocusableItemStorage: FocusableItemStorage {
+    private var itemsGroups: [String: [String: FocusableView]] = [:]
+
+    func registerItem(_ item: FocusableView) async -> Bool {
+        guard let groupId = await item.groupId,
+              let itemId = await item.itemId else { return false }
+
+        if itemsGroups[groupId] == nil {
+            itemsGroups[groupId] = [:]
+        }
+
+        itemsGroups[groupId]?[itemId] = item
+
+        return true
+    }
+
+    func unregisterItem(withId itemId: String, inGroup groupId: String) {
+        guard var groupItems = itemsGroups[groupId] else { return }
+        groupItems[itemId] = nil
+        itemsGroups[groupId] = groupItems.isEmpty ? nil : groupItems
+    }
+
+    func items(forGroup groupId: String) -> [String: FocusableView] {
+        itemsGroups[groupId] ?? [:]
+    }
+
+    func item(withId itemId: String, inGroup groupId: String) -> FocusableView? {
+        itemsGroups[groupId]?[itemId]
+    }
+}

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

@@ -0,0 +1,24 @@
+//
+//  InMemoryGroupStorage.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 10/28/24.
+//
+
+actor InMemoryFocusableGroupStorage: FocusableGroupStorage {
+    private var focusableGroups: [String: FocusableGroupView] = [:]
+
+    func registerGroup(_ group: FocusableGroupView) async -> Bool {
+        guard let id = await group.itemId else { return false }
+        focusableGroups[id] = group
+        return true
+    }
+
+    func unregisterGroup(withId groupId: String) async {
+        focusableGroups.removeValue(forKey: groupId)
+    }
+
+    func group(by groupID: String) async -> FocusableGroupView? {
+        focusableGroups[groupID]
+    }
+}

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

@@ -0,0 +1,19 @@
+//
+//  FocusableGroupManagerStorages.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 10/28/24.
+//
+
+protocol FocusableGroupStorage {
+    func registerGroup(_ group: FocusableGroupView) async -> Bool
+    func unregisterGroup(withId groupId: String) async
+    func group(by groupID: String) async -> FocusableGroupView?
+}
+
+protocol FocusableItemStorage {
+    func registerItem(_ item: FocusableView) async -> Bool
+    func unregisterItem(withId itemId: String, inGroup groupId: String) async
+    func items(forGroup groupId: String) async -> [String: FocusableView]
+    func item(withId itemId: String, inGroup groupId: String) async -> FocusableView?
+}

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

@@ -0,0 +1,29 @@
+//
+//  UpdateService.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 10/28/24.
+//
+
+import Combine
+
+struct FocusableGroupUpdateEvent {
+    let groupId: String
+    let focusableItems: [String: FocusableView]
+}
+
+class UpdateService {
+    let focusableGroupRegistrationUpdates = PassthroughSubject<FocusableGroupView, Never>()
+    let focusableItemsUpdatedAddedToGroupUpdate = PassthroughSubject<FocusableGroupUpdateEvent, Never>()
+
+    public func sendFocusableGroupRegisteredUpdate(_ focusableGroupView: FocusableGroupView) {
+        focusableGroupRegistrationUpdates.send(focusableGroupView)
+    }
+
+    public func sendFocusableItemInGroupUpdate(groupId: String,
+                                               focusableItems: [String: FocusableView]) {
+        let event = FocusableGroupUpdateEvent(groupId: groupId,
+                                              focusableItems: focusableItems)
+        focusableItemsUpdatedAddedToGroupUpdate.send(event)
+    }
+}

package/apple/tvos/ReactNativeModulesExportstvOS.m

@@ -26,7 +26,6 @@ RCT_EXPORT_VIEW_PROPERTY(initialItemId, NSString);
 RCT_EXPORT_VIEW_PROPERTY(resetFocusToInitialValue, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(isFocusDisabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(dependantGroupIds, NSArray)
-RCT_EXPORT_VIEW_PROPERTY(isManuallyBlockingFocusValue, NSNumber)
 @end
 
 @interface RCT_EXTERN_MODULE(FocusableViewModule, RCTViewManager)

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

@@ -6,19 +6,17 @@
 //  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 {
-    /// Completion that will be used when focus manager forcing to update focusable group
-    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 cancellables = Set<AnyCancellable>()
 
-    private var isManuallyBlockingFocus: Bool = false
+    /// Completion that will be used when focus manager forcing to update focusable group
+    public var didFocusCallBack: (completion: () -> Void, focusableItemId: String)?
 
     /// Notify React-Native environment that Focus Did Update
     @objc public var onDidUpdateFocus: RCTBubblingEventBlock?
@@ -42,7 +40,9 @@ public class FocusableGroupView: RCTTVView {
     @objc public var itemId: String? {
         didSet {
             if itemId != oldValue {
-                _ = FocusableGroupManager.registerFocusableGroup(group: self)
+                Task(priority: .userInitiated) {
+                    await manager.registerGroup(self)
+                }
             }
         }
     }
@@ -50,8 +50,12 @@ public class FocusableGroupView: RCTTVView {
     /// ID of the parent group, if relevant
     @objc public var groupId: String?
 
+    private var manager: FocusableGroupManager {
+        FocusableGroupManager.shared
+    }
+
     /// If this variable not nil it overrides default preffered focus environment
-    var customPrefferedFocusEnvironment: [UIFocusEnvironment]? {
+    @MainActor private var customPrefferedFocusEnvironment: [UIFocusEnvironment]? {
         didSet {
             var rootView: UIView? = self
 
@@ -76,7 +80,17 @@ 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
+    private var isGroupWasFocusedByUser = false
+
+    /// Manager that connects View instance to FocusableGroupViewModule
+    private weak var module: FocusableGroupViewModule?
+    public func setModule(_ module: FocusableGroupViewModule) {
+        self.module = module
+    }
+
+    override init(bridge: RCTBridge) {
+        super.init(bridge: bridge)
+    }
 
     override public func removeFromSuperview() {
         super.removeFromSuperview()
@@ -84,14 +98,58 @@ public class FocusableGroupView: RCTTVView {
             return
         }
 
-        // Removing when react native releases the view
-        FocusableGroupManager.unregisterFusableGroup(itemId: itemId)
+        Task {
+            // Removing when react native releases the view
+            await manager.unregisterGroup(withId: itemId)
+        }
+    }
+
+    public required init?(coder aDecoder: NSCoder) {
+        super.init(coder: aDecoder)
+        setupFocus()
+    }
+
+    override public init(frame: CGRect) {
+        super.init(frame: frame)
+        setupFocus()
+    }
+
+    private func initializeFocusGuideIfNeeded() {
+        if focusGuide == nil {
+            focusGuide = UIFocusGuide()
+        }
+    }
+
+    /// Update customPrefferedFocusEnvironment
+    ///
+    /// - Parameter view: view instance that should be preffered
+    @MainActor func updatePreferredFocusEnv(with view: UIFocusEnvironment) {
+        customPrefferedFocusEnvironment = [view]
+    }
+
+    /// Setup Focus Guide for use
+    private func setupFocus() {
+        initializeFocusGuideIfNeeded()
+
+        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
+
+        manager.focusableItemsUpdatedAddedToGroupUpdate
+            .filter { $0.groupId == self.groupId }
+            .sink { [weak self] event in
+                guard let self else { return }
+                groupItemsUpdated(groupItems: event.focusableItems)
+            }.store(in: &cancellables)
     }
 
     /// View connected to GroupView was updated
     ///
     /// - Parameter groupItems: dictionary connected to group view
-    public func groupItemsUpdated(groupItems: [String: FocusableView]) {
+    @MainActor private func groupItemsUpdated(groupItems: [String: FocusableView]) {
         guard
             isGroupWasFocusedByUser == false,
             let initialItemId,
@@ -102,7 +160,7 @@ public class FocusableGroupView: RCTTVView {
 
         let focusedView = customPrefferedFocusEnvironment?.first as? UIView
         if focusedView != initialView || focusedView == nil {
-            customPrefferedFocusEnvironment = [initialView]
+            updatePreferredFocusEnv(with: initialView)
         }
     }
 
@@ -110,7 +168,7 @@ public class FocusableGroupView: RCTTVView {
     ///
     /// - Parameter nextFocusedItem: next item that should be focused
     /// - Returns: true if reser succeed
-    func resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: UIFocusItem?) -> Bool {
+    private func resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: UIFocusItem?) async -> Bool {
         var retVal = false
         guard let nextFocusedItem else {
             return retVal
@@ -119,11 +177,11 @@ public class FocusableGroupView: RCTTVView {
         if focusItemIsDescendant(nextFocuseItem: nextFocusedItem) == false {
             if resetFocusToInitialValue,
                let initialItemId {
-                if tryTakePrefferedViewFromDependantGroups() == false {
+                if await tryTakePrefferedViewFromDependantGroups() == false {
                     if let groupId,
-                       let initialItemView = FocusableGroupManager.item(byGroupId: groupId,
-                                                                        andItemId: initialItemId) {
-                        customPrefferedFocusEnvironment = [initialItemView]
+                       let initialItemView = await manager.getItem(withId: groupId,
+                                                                   inGroup: initialItemId) {
+                        updatePreferredFocusEnv(with: initialItemView)
                         retVal = true
                     }
                 } else {
@@ -137,68 +195,26 @@ public class FocusableGroupView: RCTTVView {
     /// Try to focus on preffered item from another group
     ///
     /// - Returns: true if can focus otherwise false
-    func tryTakePrefferedViewFromDependantGroups() -> Bool {
+    private func tryTakePrefferedViewFromDependantGroups() async -> Bool {
         guard let initialItemId,
               let dependantGroupIds,
 
               let firstGroupId = dependantGroupIds.first,
-              let initialView = FocusableGroupManager.item(byGroupId: firstGroupId,
-                                                           andItemId: initialItemId)
+              let initialView = await manager.getItem(withId: firstGroupId,
+                                                      inGroup: initialItemId)
         else {
             return false
         }
 
-        customPrefferedFocusEnvironment = [initialView]
+        updatePreferredFocusEnv(with: initialView)
 
         return true
     }
 
-    /// Manager that connects View instance to FocusableGroupViewModule
-    var manager: FocusableGroupViewModule?
-
-    override init(bridge: RCTBridge) {
-        super.init(bridge: bridge)
-    }
-
-    public required init?(coder aDecoder: NSCoder) {
-        super.init(coder: aDecoder)
-        setupFocus()
-    }
-
-    override public init(frame: CGRect) {
-        super.init(frame: frame)
-        setupFocus()
-    }
-
-    func initializeFocusGuideIfNeeded() {
-        if focusGuide == nil {
-            focusGuide = UIFocusGuide()
-        }
-    }
-
-    /// Update customPrefferedFocusEnvironment
-    ///
-    /// - Parameter view: view instance that should be preffered
-    func updatePrefferedFocusEnv(with view: FocusableView) {
-        customPrefferedFocusEnvironment = [view]
-    }
-
-    /// Setup Focus Guide for use
-    func setupFocus() {
-        initializeFocusGuideIfNeeded()
-
-        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) {
+    private func sendUpdateFocusEventToReactNative(bubbleEventBlock: RCTBubblingEventBlock?, context: UIFocusUpdateContext) async {
         guard let bubbleEventBlock else {
             return
         }
@@ -225,9 +241,9 @@ public class FocusableGroupView: RCTTVView {
             if resetFocusToInitialValue,
                let initialItemId {
                 if let groupId {
-                    let groupItems = FocusableGroupManager.itemsForGroup(by: groupId)
+                    let groupItems = await manager.getItems(forGroup: groupId)
                     if let initialItemView = groupItems[initialItemId] {
-                        customPrefferedFocusEnvironment = [initialItemView]
+                        updatePreferredFocusEnv(with: initialItemView)
                     }
                 }
             }
@@ -241,7 +257,7 @@ public class FocusableGroupView: RCTTVView {
     ///
     /// - Parameter focusItem: focu item instance
     /// - Returns: dictionary instance in case data exists, otherwise nil
-    func dataForFocusItem(focusItem: Any?) -> [String: Any]? {
+    private func dataForFocusItem(focusItem: Any?) -> [String: Any]? {
         var retVal = [String: Any]()
         if let focusedView = focusItem as? RCTTVView {
             retVal[FocusItemDataKeys.describingView] = String(describing: focusedView)
@@ -256,21 +272,22 @@ public class FocusableGroupView: RCTTVView {
     /// 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)
+    @MainActor func updatePreferredFocusView(nextFocuseItem: UIFocusEnvironment?) {
+        guard let nextFocusView = nextFocuseItem,
+              let asView = nextFocusView as? UIView,
+              asView.isDescendant(of: self)
         else {
             return
         }
 
-        customPrefferedFocusEnvironment = [nextFocusView]
+        updatePreferredFocusEnv(with: 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 {
+    private func focusItemIsDescendant(nextFocuseItem: Any?) -> Bool {
         guard let nextFocusView = nextFocuseItem as? UIView,
               nextFocusView.isDescendant(of: self)
         else {
@@ -283,7 +300,7 @@ public class FocusableGroupView: RCTTVView {
     ///
     /// - Parameter focusHeading: UIFocusHeading enum
     /// - Returns: Readable string from enum
-    func focusHeadingToString(focusHeading: UIFocusHeading) -> String {
+    private func focusHeadingToString(focusHeading: UIFocusHeading) -> String {
         switch focusHeading {
         case UIFocusHeading.up:
             FocusHeadingTextValues.up
@@ -302,18 +319,6 @@ public class FocusableGroupView: RCTTVView {
         }
     }
 
-    /// Force manually focus update
-    func manuallyBlockFocus() {
-        if let isManuallyBlockingFocusValue {
-            isManuallyBlockingFocus = true
-            let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(Int(isManuallyBlockingFocusValue.floatValue * 1000))
-
-            DispatchQueue.main.asyncAfter(deadline: delay) { [weak self] in
-                self?.isManuallyBlockingFocus = false
-            }
-        }
-    }
-
     // MARK: Focus Engine
 
     override public var preferredFocusEnvironments: [UIFocusEnvironment] {
@@ -324,25 +329,30 @@ public class FocusableGroupView: RCTTVView {
     }
 
     override public func shouldUpdateFocus(in context: UIFocusUpdateContext) -> Bool {
-        guard isFocusDisabled == false,
-              isManuallyBlockingFocus == false
+        guard isFocusDisabled == false
         else {
-//                 Ignoring focus events that blocks by native side for purpose (maybe changed if future)
-            if isManuallyBlockingFocus == false {
-                sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
-                                                  context: context)
+            Task.detached(priority: .userInitiated) { [weak self] in
+                guard let self else { return }
+                await sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
+                                                        context: context)
             }
+
             return false
         }
 
         isGroupWasFocusedByUser = true
 
-        if resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: context.nextFocusedItem) == false {
-            updatePreferredFocusView(nextFocuseItem: context.nextFocusedItem)
+        Task(priority: .userInitiated) {
+            if await resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: context.nextFocusedItem) == false {
+                updatePreferredFocusView(nextFocuseItem: context.nextFocusedItem)
+            }
         }
 
-        sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
-                                          context: context)
+        Task.detached(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
+            await sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
+                                                    context: context)
+        }
 
         if focusItemIsDescendant(nextFocuseItem: context.nextFocusedItem) == false {
             isFocusDisabled = false
@@ -352,16 +362,19 @@ public class FocusableGroupView: RCTTVView {
 
     override public func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
         super.didUpdateFocus(in: context, with: coordinator)
-        manuallyBlockFocus()
         tryDidFocusCallCallback(context: context)
-        sendUpdateFocusEventToReactNative(bubbleEventBlock: onDidUpdateFocus,
-                                          context: context)
+
+        Task.detached(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
+            await 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) {
+    private func tryDidFocusCallCallback(context: UIFocusUpdateContext) {
         guard let callbackData = didFocusCallBack,
               let fousedView = context.nextFocusedView as? FocusableView,
               let itemId = fousedView.itemId
@@ -379,3 +392,9 @@ public class FocusableGroupView: RCTTVView {
         didFocusCallBack = nil
     }
 }
+
+extension FocusableGroupView: FocusableGroupProtocol {
+    var canBacomeFocusable: Bool {
+        !isFocusDisabled
+    }
+}

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

@@ -27,7 +27,7 @@ public class FocusableGroupViewModule: RCTViewManager {
 
     override public func view() -> UIView? {
         let retVal = FocusableGroupView()
-        retVal.manager = self
+        retVal.setModule(self)
         return retVal
     }
 

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

@@ -6,13 +6,21 @@
 //  Copyright © 2019 Anton Kononenko. All rights reserved.
 //
 
+import Combine
 import Foundation
 import React
 import UIKit
 
 /// RCTTVView subclass that has api how to conects to FocusableGroup
 public class FocusableView: ParallaxView {
-    weak var module: FocusableViewModule?
+    private var cancellables = Set<AnyCancellable>()
+
+    private weak var module: FocusableViewModule?
+    func setModule(_ module: FocusableViewModule) {
+        self.module = module
+    }
+
+    @MainActor private weak var focusableGroup: FocusableGroupProtocol?
 
     @objc public var onViewFocus: RCTBubblingEventBlock?
     @objc public var onViewPress: RCTBubblingEventBlock?
@@ -32,22 +40,67 @@ public class FocusableView: ParallaxView {
     /// Define if view can become focused
     @objc open var focusable = true
 
-    @objc public var preferredFocus: Bool = false {
+    private var manager: FocusableGroupManager {
+        FocusableGroupManager.shared
+    }
+
+    @MainActor @objc public var preferredFocus: Bool = false {
         didSet {
             guard preferredFocus else {
                 return
             }
-            DispatchQueue.main.async { [weak self] in
-                if let groupId = self?.groupId,
-                   let focusableGroup = focusableGroups[groupId] {
-                    // Update Prefered focus view in group
-                    focusableGroup.updatePrefferedFocusEnv(with: self!)
-                }
+
+            if let focusableGroup {
+                // Update Prefered focus view in group
+                focusableGroup.updatePreferredFocusEnv(with: self)
             }
         }
     }
 
-    var isFocusLayoutConfigured = false
+    private var isFocusLayoutConfigured = false
+
+    /// Define if view was registered
+    private var isViewRegistered: Bool = false
+
+    override public init(frame: CGRect) {
+        super.init(frame: frame)
+        initialize()
+    }
+
+    public required init?(coder aDecoder: NSCoder) {
+        super.init(coder: aDecoder)
+        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()
+        }
+    }
+
+    /// ID of the View provided by React-Native env
+    @objc private(set) var groupId: String? {
+        didSet {
+            registerView()
+        }
+    }
+
     override public func layoutSubviews() {
         super.layoutSubviews()
 
@@ -57,6 +110,23 @@ 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
+            }
+        }
+    }
+
 //    TODO: Example of solution for future with groupId and focuse id
 //    func hintLeftFocusId() {
 //        if let onFocusLeft = dictFromReactNative,
@@ -77,12 +147,13 @@ public class FocusableView: ParallaxView {
             return
         }
 
-        // Removing when react native releases the view
-        FocusableGroupManager.unregisterFusableItem(itemId: itemId, groupId: groupId)
+        Task {
+            await FocusableGroupManager.shared.unregisterItem(withId: itemId, inGroup: groupId)
+        }
     }
 
-    func addFocusGuideIfNeeded(tag: NSNumber?,
-                               direction: UIRectEdge) {
+    private func addFocusGuideIfNeeded(tag: NSNumber?,
+                                       direction: UIRectEdge) {
         if let tag,
            let view = module?.viewForTag(tag: tag) {
             _ = addFocusGuide(from: self,
@@ -92,7 +163,7 @@ public class FocusableView: ParallaxView {
         }
     }
 
-    func configureFocusLayout() {
+    private func configureFocusLayout() {
         addFocusGuideIfNeeded(tag: nextTvosFocusLeft, direction: .left)
         addFocusGuideIfNeeded(tag: nextTvosFocusRight, direction: .right)
         addFocusGuideIfNeeded(tag: nextTvosFocusUp, direction: .top)
@@ -147,60 +218,18 @@ public class FocusableView: ParallaxView {
             }
 
             DispatchQueue.main.async { [weak self] in
-                FocusableGroupManager.updateFocus(self?.groupId,
-                                                  itemId: self?.itemId,
-                                                  needsForceUpdate: true,
-                                                  completion: nil)
+                FocusableGroupManager.shared.updateFocus(groupId: self?.groupId,
+                                                         itemId: self?.itemId,
+                                                         needsForceUpdate: true)
             }
         }
     }
 
     override public var canBecomeFocused: Bool {
-        focusable
-    }
-
-    /// Define if view was registered
-    var isViewRegistered: Bool = false
-
-    override public init(frame: CGRect) {
-        super.init(frame: frame)
-        initialize()
-    }
-
-    public required init?(coder aDecoder: NSCoder) {
-        super.init(coder: aDecoder)
-        initialize()
-    }
-
-    /// Initialize component
-    func initialize() {
-        delegate = self
-    }
-
-    /// ID of the View provided by React-Native env
-    @objc public var itemId: String? {
-        didSet {
-            registerView()
-        }
-    }
-
-    /// ID of the View provided by React-Native env
-    @objc public var groupId: String? {
-        didSet {
-            registerView()
-        }
-    }
-
-    /// Register View in FocusableGroupManager
-    func registerView() {
-        guard itemId != nil,
-              groupId != nil,
-              isViewRegistered == false,
-              FocusableGroupManager.registerView(item: self)
-        else {
-            return
+        guard let focusableGroup else {
+            return focusable
         }
 
-        isViewRegistered = true
+        return focusableGroup.canBacomeFocusable && focusable
     }
 }

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

@@ -27,7 +27,7 @@ public class FocusableViewModule: RCTViewManager {
 
     override public func view() -> UIView? {
         let view = FocusableView()
-        view.module = self
+        view.setModule(self)
 
         return view
     }

package/apple/tvos/Views/ParallaxView/Protocols/FocusableGroupProtocol.swift

@@ -0,0 +1,11 @@
+//
+//  FocusableGroupProtocol.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 10/28/24.
+//
+
+protocol FocusableGroupProtocol: AnyObject {
+    var canBacomeFocusable: Bool { get }
+    @MainActor func updatePreferredFocusEnv(with view: UIFocusEnvironment)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-native-apple",
-  "version": "6.9.4",
+  "version": "6.9.5",
   "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"