@applicaster/quick-brick-native-apple 6.13.0 → 6.14.0

package/apple/QuickBrickApple.podspec.json

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

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

@@ -0,0 +1,181 @@
+//
+//  FocusableGroupManager+MovementDidFailNotification.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 9/12/25.
+//
+
+import React
+import UIKit
+
+extension FocusableGroupManager {
+    public func registerForMovementDidFailNotification() {
+        NotificationCenter.default.addObserver(
+            forName: UIFocusSystem.movementDidFailNotification,
+            object: nil,
+            queue: .main
+        ) { n in
+            guard let rootViewController = UIApplication.shared.rootViewController(),
+                  let rootView = rootViewController.view as? RCTRootView,
+                  let userInfo = n.userInfo,
+                  let ctx = userInfo[UIFocusSystem.focusUpdateContextUserInfoKey] as? UIFocusUpdateContext else { return }
+            let prev = ctx.previouslyFocusedItem as? UIView
+            let next = ctx.nextFocusedItem as? UIView
+
+            Task { @MainActor
+                [weak self] in
+                guard let self else { return }
+                logFocusError(userInfo: userInfo,
+                              ctx: ctx,
+                              prev: prev,
+                              next: next)
+
+                // TODO: Unocomment for debugging
+                // simulateFocusUpdateRequest(prev: prev, next: next)
+
+                await tryToRestoreCorruptedFocusState(rootView: rootView, next: next)
+            }
+        }
+    }
+
+    @MainActor
+    private func tryToRestoreCorruptedFocusState(rootView: RCTRootView, next: UIView?) async {
+        guard let next else { return }
+
+        rootView.reactPreferredFocusEnvironments = [next]
+
+        rootView.setNeedsFocusUpdate()
+        rootView.updateFocusIfNeeded()
+
+        DispatchQueue.main.async {
+            rootView.reactPreferredFocusEnvironments = []
+            rootView.reactPreferredFocusedView = nil
+        }
+    }
+
+    private func simulateFocusUpdateRequest(prev: UIView?, next: UIView?) {
+        guard let prev,
+              let next else { return }
+        let container = lowestCommonAncestor(prev, next)
+            ?? next.window?.rootViewController?.view
+            ?? prev
+
+        let guide = UIFocusGuide()
+
+        container.addLayoutGuide(guide)
+        NSLayoutConstraint.activate([
+            guide.topAnchor.constraint(equalTo: container.topAnchor),
+            guide.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+            guide.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            guide.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+        ])
+        guide.preferredFocusEnvironments = [next]
+
+        let sim = UIFocusDebugger.simulateFocusUpdateRequest(from: container)
+        print("⚠️ Simulation result:\n\(sim)")
+
+        print("⚠️ Focus groups (next):\n\(UIFocusDebugger.focusGroups(for: next))")
+        print("⚠️ Preferred chain (next):\n\(UIFocusDebugger.preferredFocusEnvironments(for: next))")
+
+        container.removeLayoutGuide(guide)
+    }
+
+    private func logFocusError(userInfo _: [AnyHashable: Any],
+                               ctx: UIFocusUpdateContext,
+                               prev: UIView?,
+                               next: UIView?) {
+        print("⚠️ Focus movement FAILED. heading=\(ctx.focusHeading.rawValue)")
+        print("  prev=\(String(describing: prev))")
+        print("  next=\(String(describing: next))")
+
+        if let next {
+            print("  ▶︎ UIFocusDebugger.checkFocusability(next):")
+            print(UIFocusDebugger.checkFocusability(for: next))
+
+            let g = rectOnScreen(next)
+            print("  ▶︎ Geometry next: inWindow=\(String(describing: g.inWindow)) window=\(String(describing: g.windowBounds)) onScreen=\(g.onScreen)")
+
+            print("  ▶︎ Focus chain (next): \(focusPath(next))")
+        }
+        if let prev {
+            let g = rectOnScreen(prev)
+            print("  ▶︎ Geometry prev: inWindow=\(String(describing: g.inWindow)) onScreen=\(g.onScreen)")
+            print("  ▶︎ Focus chain (prev): \(focusPath(prev))")
+        }
+    }
+
+    // MARK: - Geometry
+
+    /// Returns the view's rect in window coords, the window bounds, and whether it's (even partially) on-screen.
+    func rectOnScreen(_ view: UIView) -> (inWindow: CGRect?, windowBounds: CGRect?, onScreen: Bool) {
+        guard let win = view.window else {
+            return (nil, nil, false)
+        }
+        let inWin = view.convert(view.bounds, to: win)
+        let on = inWin.intersects(win.bounds) && !inWin.isEmpty
+        return (inWin, win.bounds, on)
+    }
+
+    // MARK: - Focus path
+
+    func focusPath(_ env: UIFocusEnvironment) -> String {
+        var names: [String] = []
+        var cursor: UIFocusEnvironment? = env
+
+        func name(_ obj: AnyObject) -> String {
+            let cls = String(describing: type(of: obj))
+            if obj is UIView {
+                return "\(cls)"
+            } else if obj is UIViewController {
+                return "\(cls)"
+            } else {
+                return cls
+            }
+        }
+
+        while let e = cursor as AnyObject? {
+            names.append(name(e))
+            if let v = e as? UIView {
+                cursor = v.superview ?? v.next as? UIFocusEnvironment ?? v.parentFocusEnvironment
+            } else if let vc = e as? UIViewController {
+                cursor = vc.parent ?? vc.view?.superview ?? vc.parentFocusEnvironment
+            } else {
+                cursor = (e as? UIFocusEnvironment)?.parentFocusEnvironment
+            }
+
+            if e is UIApplication { break }
+            if String(describing: type(of: e)) == "AppDelegate" { break }
+        }
+
+        return names.joined(separator: " → ")
+    }
+
+    func lowestCommonAncestor(_ a: UIView, _ b: UIView) -> UIView? {
+        var seen = Set<ObjectIdentifier>()
+        var x: UIView? = a
+        while let v = x {
+            seen.insert(ObjectIdentifier(v)); x = v.superview
+        }
+        var y: UIView? = b
+        while let v = y {
+            if seen.contains(ObjectIdentifier(v)) { return v }
+            y = v.superview
+        }
+        return nil
+    }
+
+    @inline(__always)
+    func currentFocusedItem(relativeTo view: UIView?) -> UIFocusItem? {
+        if #available(tvOS 15.0, *) {
+            if let fs = view?.window?.windowScene?.focusSystem { return fs.focusedItem }
+            // Fallback if you don't have a view handy:
+            for scene in UIApplication.shared.connectedScenes {
+                if let ws = scene as? UIWindowScene { return ws.focusSystem?.focusedItem }
+            }
+            return nil
+        } else {
+            // tvOS < 15
+            return UIScreen.main.focusedItem
+        }
+    }
+}

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

@@ -29,11 +29,13 @@ class FocusableGroupManager {
         self.groupStorage = groupStorage
         self.itemStorage = itemStorage
         self.updateService = updateService
+
+        registerForMovementDidFailNotification()
     }
 
     // MARK: - Group Managment
 
-    public func registerGroup(_ group: FocusableGroupView) async -> Bool {
+    func registerGroup(_ group: FocusableGroupView) async -> Bool {
         let wasRegistered = await groupStorage.registerGroup(group)
         guard wasRegistered else {
             return false
@@ -43,7 +45,7 @@ class FocusableGroupManager {
         return true
     }
 
-    public func unregisterGroup(withId groupId: String) async {
+    func unregisterGroup(withId groupId: String) async {
         await groupStorage.unregisterGroup(withId: groupId)
         let items = await itemStorage.items(forGroup: groupId)
         for itemId in items.keys {
@@ -51,13 +53,13 @@ class FocusableGroupManager {
         }
     }
 
-    public func getGroup(by groupID: String) async -> FocusableGroupView? {
+    func getGroup(by groupID: String) async -> FocusableGroupView? {
         await groupStorage.group(by: groupID)
     }
 
     // MARK: - Item Management
 
-    public func registerItem(_ item: FocusableView) async -> Bool {
+    func registerItem(_ item: FocusableView) async -> Bool {
         let success = await itemStorage.registerItem(item)
         if success,
            let groupId = await item.groupId {
@@ -70,19 +72,19 @@ class FocusableGroupManager {
         return success
     }
 
-    public func unregisterItem(withId itemId: String, inGroup groupId: String) async {
+    func unregisterItem(withId itemId: String, inGroup groupId: String) async {
         await itemStorage.unregisterItem(withId: itemId, inGroup: groupId)
     }
 
-    public func getItems(forGroup groupId: String) async -> [String: FocusableView] {
+    func getItems(forGroup groupId: String) async -> [String: FocusableView] {
         await itemStorage.items(forGroup: groupId)
     }
 
-    public func getItem(withId itemId: String, inGroup groupId: String) async -> FocusableView? {
+    func getItem(withId itemId: String, inGroup groupId: String) async -> FocusableView? {
         await itemStorage.item(withId: itemId, inGroup: groupId)
     }
 
-    public func notifyFocusableItemDidUpdatePreferredFocus(focusableView: FocusableView) {
+    func notifyFocusableItemDidUpdatePreferredFocus(focusableView: FocusableView) {
         updateService.sendFocusableItemDidUpdatePreferredFocus(focusableView)
     }
 
@@ -93,10 +95,10 @@ 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
-    public func updateFocus(groupId: String?,
-                            itemId: String?,
-                            needsForceUpdate: Bool = false,
-                            completion: ((Bool) -> Void)? = nil) {
+    func updateFocus(groupId: String?,
+                     itemId: String?,
+                     needsForceUpdate: Bool = false,
+                     completion: ((Bool) -> Void)? = nil) {
         Task { @MainActor in
             guard
                 let groupId,

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

@@ -18,18 +18,18 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
     var delayTimer = 100
 
     /// main React bridge
-    public var bridge: RCTBridge?
+    var bridge: RCTBridge?
 
     static func moduleName() -> String! {
         kFocusableManagerModule
     }
 
-    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/tvos/Helpers/FocusableGroupManager/Protocols/UpdateService.swift

@@ -16,11 +16,11 @@ class UpdateService {
     let focusableGroupRegistrationUpdates = PassthroughSubject<FocusableGroupView, Never>()
     let focusableItemDidUpdatePreferredFocus = PassthroughSubject<FocusableView, Never>()
 
-    public func sendFocusableGroupRegisteredUpdate(_ focusableGroupView: FocusableGroupView) {
+    func sendFocusableGroupRegisteredUpdate(_ focusableGroupView: FocusableGroupView) {
         focusableGroupRegistrationUpdates.send(focusableGroupView)
     }
 
-    public func sendFocusableItemDidUpdatePreferredFocus(_ focusableView: FocusableView) {
+    func sendFocusableItemDidUpdatePreferredFocus(_ focusableView: FocusableView) {
         focusableItemDidUpdatePreferredFocus.send(focusableView)
     }
 }

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

@@ -7,16 +7,34 @@
 
 import Foundation
 
-class FocusGuideDebugView: UIView {
+final class FocusGuideDebugView: UIView {
+    private weak var guide: UIFocusGuide?
+
     init(focusGuide: UIFocusGuide) {
-        super.init(frame: focusGuide.layoutFrame)
-        backgroundColor = UIColor.green.withAlphaComponent(0.15)
-        layer.borderColor = UIColor.green.withAlphaComponent(0.3).cgColor
-        layer.borderWidth = 1
+        super.init(frame: .zero)
+        guide = focusGuide
+
+        backgroundColor = UIColor.red.withAlphaComponent(0.15)
+        layer.borderColor = UIColor.red.withAlphaComponent(1).cgColor
+        layer.borderWidth = 20
+
+        translatesAutoresizingMaskIntoConstraints = false
+
+        if let container = focusGuide.owningView {
+            container.addSubview(self)
+
+            NSLayoutConstraint.activate([
+                leftAnchor.constraint(equalTo: focusGuide.leftAnchor),
+                rightAnchor.constraint(equalTo: focusGuide.rightAnchor),
+                topAnchor.constraint(equalTo: focusGuide.topAnchor),
+                bottomAnchor.constraint(equalTo: focusGuide.bottomAnchor),
+            ])
+        }
     }
 
+    @available(*, unavailable)
     required init?(coder _: NSCoder) {
-        nil
+        fatalError("init(coder:) has not been implemented")
     }
 }
 

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

@@ -226,7 +226,6 @@ public class FocusableView: ParallaxView {
             }
 
             DispatchQueue.main.async { [weak self] in
-
                 FocusableGroupManager.shared.updateFocus(groupId: self?.groupId,
                                                          itemId: self?.itemId,
                                                          needsForceUpdate: true)

package/package.json

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