@applicaster/quick-brick-native-apple 6.9.9 → 6.11.0-alpha.0

package/apple/QuickBrickApple.podspec.json

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

package/apple/tvos/ReactNativeModulesExportstvOS.m

@@ -18,14 +18,13 @@ RCT_EXTERN_METHOD(setPreferredFocus:(NSString *)groupId itemId:(NSString *)itemI
 @end
 
 @interface RCT_EXTERN_MODULE(FocusableGroupViewModule, RCTViewManager)
-RCT_EXPORT_VIEW_PROPERTY(onWillUpdateFocus, RCTBubblingEventBlock);
-RCT_EXPORT_VIEW_PROPERTY(onDidUpdateFocus, RCTBubblingEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(onGroupFocus, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onGroupBlur, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(itemId, NSString);
 RCT_EXPORT_VIEW_PROPERTY(groupId, NSString);
 RCT_EXPORT_VIEW_PROPERTY(initialItemId, NSString);
-RCT_EXPORT_VIEW_PROPERTY(resetFocusToInitialValue, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(isPreferredFocusEnvironmentDisabled, BOOL);
 RCT_EXPORT_VIEW_PROPERTY(isFocusDisabled, BOOL);
-RCT_EXPORT_VIEW_PROPERTY(dependantGroupIds, NSArray)
 @end
 
 @interface RCT_EXTERN_MODULE(FocusableViewModule, RCTViewManager)
@@ -35,9 +34,9 @@ RCT_EXPORT_VIEW_PROPERTY(forceFocus, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(preferredFocus, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(isParallaxDisabled, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(isPressDisabled, BOOL)
-RCT_EXPORT_VIEW_PROPERTY(onViewPress, RCTBubblingEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onViewFocus, RCTBubblingEventBlock)
-RCT_EXPORT_VIEW_PROPERTY(onViewBlur, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onViewPress, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onViewFocus, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onViewBlur, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(focusable, BOOL);
 
 //TODO: We need only in cases where we can not focus with focusable group

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

@@ -0,0 +1,38 @@
+//
+//  FocusableGroupStateNotifier.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 3/21/25.
+
+public protocol FocusableGroupStateNotifier: AnyObject {
+    var isActive: Bool { get }
+    func updateFocus(currentlyActive: Bool,
+                     context: UIFocusUpdateContext)
+}
+
+enum FocusableGroupNotifierActionType {
+    case onBlur
+    case onFocus
+}
+
+typealias NotifierActionType = (_ type: FocusableGroupNotifierActionType, _ context: UIFocusUpdateContext) -> Void
+
+class FocusableGroupStateNotifierDefault: FocusableGroupStateNotifier {
+    private(set) var isActive: Bool = false
+
+    let action: NotifierActionType
+    init(action: @escaping NotifierActionType) {
+        self.action = action
+    }
+
+    func updateFocus(currentlyActive: Bool, context: UIFocusUpdateContext) {
+        guard currentlyActive != isActive else { return }
+
+        isActive = currentlyActive
+        sendNotifierEvent(context: context)
+    }
+
+    func sendNotifierEvent(context: UIFocusUpdateContext) {
+        action(isActive ? .onFocus : .onBlur, context)
+    }
+}

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

@@ -12,17 +12,21 @@ import React
 import UIKit
 
 /// Focusable  Group View that implements UIFocusGuide instance that catches focus event
+///
 public class FocusableGroupView: RCTTVView {
+    override public var debugDescription: String {
+        "GROUP_ID: \(groupId ?? "NONE"), ID: \(itemId ?? "NONE"), \(super.debugDescription)"
+    }
+
     private var cancellables = Set<AnyCancellable>()
 
     /// Completion that will be used when focus manager forcing to update focusable group
     public var didFocusCallBack: (completion: () -> Void, focusableItemId: String)?
 
-    /// Notify React-Native environment that Focus Did Update
-    @objc public var onDidUpdateFocus: RCTBubblingEventBlock?
+    private var activeStateNotifier: FocusableGroupStateNotifier?
 
-    /// Notify React-Native environment that Focus Will Update
-    @objc public var onWillUpdateFocus: RCTBubblingEventBlock?
+    @objc public var onGroupFocus: RCTDirectEventBlock?
+    @objc public var onGroupBlur: RCTDirectEventBlock?
 
     /// Define if focus enabled for current view
     @objc public var isFocusDisabled: Bool = false
@@ -30,11 +34,15 @@ public class FocusableGroupView: RCTTVView {
     /// Current group will try to find initial index id in groups
     @objc public var dependantGroupIds: [String]?
 
-    /// Check if preferred focus has to be reset to initial value, after group becomes inactive
-    @objc public var resetFocusToInitialValue: Bool = false
+    /// Check if preferred focus environment disabled
+    @objc public var isPreferredFocusDisabled: Bool = false
 
     /// ID of the item that must be focused as init focus
-    @objc public var initialItemId: String?
+    @objc public var initialItemId: String? {
+        didSet {
+            updateInitialItemId()
+        }
+    }
 
     /// ID of the Connected GroupView provided by React-Native env
     @objc public var itemId: String? {
@@ -54,38 +62,14 @@ public class FocusableGroupView: RCTTVView {
         FocusableGroupManager.shared
     }
 
-    /// If this variable not nil it overrides default preffered focus environment
-    @MainActor private var customPrefferedFocusEnvironment: [UIFocusEnvironment]? {
-        didSet {
-            var rootView: UIView? = self
-
-            while rootView?.superview != nil {
-                if let unwrapedRootView = rootView,
-                   let superView = unwrapedRootView.superview {
-                    rootView = superView
-                    if let superFocusGroup = rootView as? FocusableGroupView {
-                        if let newFocusData = customPrefferedFocusEnvironment as? [FocusableView],
-                           let superFocusGroupFocusEnvironment = superFocusGroup.customPrefferedFocusEnvironment as? [FocusableView] {
-                            let groupIdsToStay = newFocusData.map(\.groupId)
-                            let filteredGroups = superFocusGroupFocusEnvironment.filter { !groupIdsToStay.contains($0.groupId) }
-                            superFocusGroup.customPrefferedFocusEnvironment = filteredGroups + newFocusData
-                        } else {
-                            superFocusGroup.customPrefferedFocusEnvironment = customPrefferedFocusEnvironment
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /// Check if group has an initial focus
-    /// Note: In case Initial init when app start not calling shouldFocusUpdate
-    private var isGroupWasFocusedByUser = false
+    /// If this variable not nil it overrides default preferred focus environment
+    @MainActor private var customPreferredFocusEnvironment: [UIFocusEnvironment]?
 
     /// Manager that connects View instance to FocusableGroupViewModule
     private weak var module: FocusableGroupViewModule?
     public func setModule(_ module: FocusableGroupViewModule) {
         self.module = module
+        activeStateNotifier = FocusableGroupStateNotifierDefault(action: notifyReactNativeFocusUpdate)
     }
 
     override init(bridge: RCTBridge) {
@@ -117,22 +101,17 @@ public class FocusableGroupView: RCTTVView {
         setupFocus()
     }
 
-    private func initializeFocusGuideIfNeeded() {
-        if focusGuide == nil {
-            focusGuide = UIFocusGuide()
-        }
-    }
-
-    /// Update customPrefferedFocusEnvironment
+    /// Update customPreferredFocusEnvironment
     ///
-    /// - Parameter view: view instance that should be preffered
+    /// - Parameter view: view instance that should be preferred
     @MainActor func updatePreferredFocusEnv(with view: UIFocusEnvironment) {
-        customPrefferedFocusEnvironment = [view]
+        focusGuide.preferredFocusEnvironments = [view]
+        customPreferredFocusEnvironment = [view]
     }
 
     /// Setup Focus Guide for use
     private func setupFocus() {
-        initializeFocusGuideIfNeeded()
+        focusGuide = UIFocusGuide()
 
         addLayoutGuide(focusGuide)
 
@@ -143,117 +122,53 @@ public class FocusableGroupView: RCTTVView {
 
         manager.focusableItemsUpdatedAddedToGroupUpdate
             .filter { $0.groupId == self.groupId }
-            .sink { [weak self] event in
+            .sink { [weak self] _ in
                 guard let self else { return }
-                groupItemsUpdated(groupItems: event.focusableItems)
+                updateInitialItemId()
             }.store(in: &cancellables)
     }
 
-    /// View connected to GroupView was updated
-    ///
-    /// - Parameter groupItems: dictionary connected to group view
-    @MainActor private func groupItemsUpdated(groupItems: [String: FocusableView]) {
-        guard
-            isGroupWasFocusedByUser == false,
-            let initialItemId,
-            let initialView = groupItems[initialItemId]
-        else {
-            return
-        }
-
-        let focusedView = customPrefferedFocusEnvironment?.first as? UIView
-        if focusedView != initialView || focusedView == nil {
-            updatePreferredFocusEnv(with: initialView)
-        }
-    }
-
-    /// Reset focus to initial state if needed
-    ///
-    /// - Parameter nextFocusedItem: next item that should be focused
-    /// - Returns: true if reser succeed
-    private func resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: UIFocusItem?) async -> Bool {
-        var retVal = false
-        guard let nextFocusedItem else {
-            return retVal
-        }
+    /// Update initial item id
+    @MainActor private func updateInitialItemId() {
+        Task(priority: .userInitiated) { [weak self] in
+            guard let self else { return }
 
-        if focusItemIsDescendant(nextFocuseItem: nextFocusedItem) == false {
-            if resetFocusToInitialValue,
-               let initialItemId {
-                if await tryTakePrefferedViewFromDependantGroups() == false {
-                    if let groupId,
-                       let initialItemView = await manager.getItem(withId: groupId,
-                                                                   inGroup: initialItemId) {
-                        updatePreferredFocusEnv(with: initialItemView)
-                        retVal = true
-                    }
-                } else {
-                    retVal = true
-                }
+            guard
+                let initialItemId,
+                let initialView = await manager.getItem(withId: initialItemId, inGroup: initialItemId)
+            else {
+                return
             }
-        }
-        return retVal
-    }
 
-    /// Try to focus on preffered item from another group
-    ///
-    /// - Returns: true if can focus otherwise false
-    private func tryTakePrefferedViewFromDependantGroups() async -> Bool {
-        guard let initialItemId,
-              let dependantGroupIds,
-
-              let firstGroupId = dependantGroupIds.first,
-              let initialView = await manager.getItem(withId: firstGroupId,
-                                                      inGroup: initialItemId)
-        else {
-            return false
+            updatePreferredFocusEnv(with: initialView)
         }
-
-        updatePreferredFocusEnv(with: initialView)
-
-        return true
     }
 
-    /// Send update focus event to Reactnative
-    ///
-    /// - Parameter context: Update UIFocusUpdateContext instance
-    private func sendUpdateFocusEventToReactNative(bubbleEventBlock: RCTBubblingEventBlock?, context: UIFocusUpdateContext) async {
-        guard let bubbleEventBlock else {
-            return
-        }
-        let focusHeading = focusHeadingToString(focusHeading: context.focusHeading)
-        var params: [String: Any] = [GroupViewUpdateEvents.focusHeading: focusHeading]
-
-        params[GroupViewUpdateEvents.isFocusingByUser] = focusHeading != FocusHeadingTextValues.manualUpdate
+    private func createFocusEventParams(context: UIFocusUpdateContext, isActive: Bool) -> [String: Any] {
+        var params: [String: Any] = [
+            GroupViewUpdateEvents.focusHeading: focusHeadingToString(focusHeading: context.focusHeading),
+            GroupViewUpdateEvents.isFocusingByUser: focusHeadingToString(focusHeading: context.focusHeading) != FocusHeadingTextValues.manualUpdate,
+        ]
 
         params[GroupViewUpdateEvents.previouslyFocusedItem] = dataForFocusItem(focusItem: context.previouslyFocusedView)
         params[GroupViewUpdateEvents.nextFocusedItem] = dataForFocusItem(focusItem: context.nextFocusedView)
-        params[GroupViewUpdateEvents.prefferedFocusEnvironment] = dataForFocusItem(focusItem: customPrefferedFocusEnvironment?.first)
+        params[GroupViewUpdateEvents.preferredFocusEnvironment] = dataForFocusItem(focusItem: customPreferredFocusEnvironment?.first)
         params[GroupViewUpdateEvents.groupId] = groupId
+        params[GroupViewUpdateEvents.isActive] = isActive
+        params[GroupViewUpdateEvents.isFocusDisabled] = isFocusDisabled
+        params[GroupViewUpdateEvents.itemId] = itemId
 
-        if let focusableView = context.nextFocusedItem as? FocusableView {
-            params[GroupViewUpdateEvents.itemId] = focusableView.itemId
-        }
+        return params
+    }
 
-        if focusItemIsDescendant(nextFocuseItem: context.nextFocusedItem) {
-            params[GroupViewUpdateEvents.isActive] = true
-
-        } else {
-            params[GroupViewUpdateEvents.isActive] = false
-            isFocusDisabled = false
-            if resetFocusToInitialValue,
-               let initialItemId {
-                if let groupId {
-                    let groupItems = await manager.getItems(forGroup: groupId)
-                    if let initialItemView = groupItems[initialItemId] {
-                        updatePreferredFocusEnv(with: initialItemView)
-                    }
-                }
-            }
+    private func notifyReactNativeFocusUpdate(_ type: FocusableGroupNotifierActionType,
+                                              _ context: UIFocusUpdateContext) {
+        switch type {
+        case .onBlur:
+            onGroupBlur?(createFocusEventParams(context: context, isActive: false))
+        case .onFocus:
+            onGroupFocus?(createFocusEventParams(context: context, isActive: true))
         }
-        params[GroupViewUpdateEvents.isFocusDisabled] = isFocusDisabled
-
-        bubbleEventBlock(params)
     }
 
     /// Data for Focus Item that will be passed to React-Native env
@@ -272,11 +187,11 @@ public class FocusableGroupView: RCTTVView {
         return retVal.keys.count == 0 ? nil : retVal
     }
 
-    /// Update preffered Focus View for focuse guide if next focuasable view is part of this focus guide
+    /// Update preferred Focus View for focus guide if next focusable view is part of this focus guide
     ///
-    /// - Parameter nextFocuseItem: next focus item instance
-    @MainActor func updatePreferredFocusView(nextFocuseItem: UIFocusEnvironment?) {
-        guard let nextFocusView = nextFocuseItem,
+    /// - Parameter nextFocusItem: next focus item instance
+    @MainActor func updatePreferredFocusView(nextFocusItem: UIFocusEnvironment?) {
+        guard let nextFocusView = nextFocusItem,
               let asView = nextFocusView as? UIView,
               asView.isDescendant(of: self)
         else {
@@ -290,8 +205,8 @@ public class FocusableGroupView: RCTTVView {
     ///
     /// - Parameter nextFocuseItem: next item to focus
     /// - Returns: true if next focus item part of this group instance
-    private func focusItemIsDescendant(nextFocuseItem: Any?) -> Bool {
-        guard let nextFocusView = nextFocuseItem as? UIView,
+    private func focusItemIsDescendant(nextFocusItem: Any?) -> Bool {
+        guard let nextFocusView = nextFocusItem as? UIView,
               nextFocusView.isDescendant(of: self)
         else {
             return false
@@ -325,53 +240,62 @@ public class FocusableGroupView: RCTTVView {
     // MARK: Focus Engine
 
     override public var preferredFocusEnvironments: [UIFocusEnvironment] {
-        if let customPrefferedFocusEnvironment {
-            return customPrefferedFocusEnvironment
-        }
-        return super.preferredFocusEnvironments
+        customPreferredFocusEnvironment ?? super.preferredFocusEnvironments
     }
 
-    override public func shouldUpdateFocus(in context: UIFocusUpdateContext) -> Bool {
-        guard isFocusDisabled == false
-        else {
-            Task.detached(priority: .userInitiated) { [weak self] in
-                guard let self else { return }
-                await sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
-                                                        context: context)
-            }
+    override public func shouldUpdateFocus(in _: UIFocusUpdateContext) -> Bool {
+        isFocusDisabled == false
+    }
 
-            return false
-        }
+    // This was added because on fast scroll preferred focus was not called,
+    // that cause to select wrong item. On future must be removed if resolved
+    private func needsFocusUpdateDueToWrongFocus(context: UIFocusUpdateContext,
+                                                 with coordinator: UIFocusAnimationCoordinator) -> Bool {
+        guard
+            let preferredFocusedItem = customPreferredFocusEnvironment?.first as? FocusableView,
+            let nextFocusedItem = context.nextFocusedItem as? FocusableView,
+            let previouslyFocusedItem = context.previouslyFocusedItem as? FocusableView else { return false }
 
-        isGroupWasFocusedByUser = true
+        let previousFocusedItemNotFromSameGroup = previouslyFocusedItem.groupId != nextFocusedItem.groupId
+        let nextFocusedBelongsToCurrentGroup = nextFocusedItem.groupId == itemId
+        let nextFocusItemNotPreferredFocusedItem = nextFocusedItem.itemId != preferredFocusedItem.itemId
 
-        Task(priority: .userInitiated) {
-            if await resetFocusPrefferedEnvironmentIfNeeded(nextFocusedItem: context.nextFocusedItem) == false {
-                updatePreferredFocusView(nextFocuseItem: context.nextFocusedItem)
-            }
+        guard previousFocusedItemNotFromSameGroup,
+              nextFocusedBelongsToCurrentGroup,
+              nextFocusItemNotPreferredFocusedItem else {
+            return false
         }
 
-        Task.detached(priority: .userInitiated) { [weak self] in
-            guard let self else { return }
-            await sendUpdateFocusEventToReactNative(bubbleEventBlock: onWillUpdateFocus,
-                                                    context: context)
-        }
+        coordinator.addCoordinatedAnimations({
+            let duration: TimeInterval = UIView.inheritedAnimationDuration
+            UIView.animate(withDuration: duration,
+                           delay: 0.0,
+                           options: [],
+                           animations: {
+                               self.setNeedsFocusUpdate()
+                               self.updateFocusIfNeeded()
+                           }, completion: nil)
+        }, completion: nil)
 
-        if focusItemIsDescendant(nextFocuseItem: context.nextFocusedItem) == false {
-            isFocusDisabled = false
-        }
         return true
     }
 
     override public func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
-        super.didUpdateFocus(in: context, with: coordinator)
-        tryDidFocusCallCallback(context: context)
+        guard isFocusDisabled == false else { return }
 
-        Task.detached(priority: .userInitiated) { [weak self] in
-            guard let self else { return }
-            await sendUpdateFocusEventToReactNative(bubbleEventBlock: onDidUpdateFocus,
-                                                    context: context)
+        guard needsFocusUpdateDueToWrongFocus(context: context,
+                                              with: coordinator) == false else {
+            return
+        }
+
+        if isPreferredFocusDisabled == false {
+            updatePreferredFocusView(nextFocusItem: context.nextFocusedItem)
         }
+
+        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

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

@@ -22,7 +22,7 @@ public enum GroupViewUpdateEvents {
     static let focusHeading = "focusHeading"
     static let previouslyFocusedItem = "previouslyFocusedItem"
     static let nextFocusedItem = "nextFocusedItem"
-    static let prefferedFocusEnvironment = "prefferedFocusEnvironment"
+    static let preferredFocusEnvironment = "preferredFocusEnvironment"
     static let groupId = "groupId"
     static let itemId = "itemId"
     static let isActive = "isActive"

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

@@ -13,6 +13,10 @@ import UIKit
 
 /// RCTTVView subclass that has api how to conects to FocusableGroup
 public class FocusableView: ParallaxView {
+    override public var debugDescription: String {
+        "GROUP_ID: \(groupId ?? "NONE"), ID: \(itemId ?? "NONE"), \(super.debugDescription)"
+    }
+
     private var cancellables = Set<AnyCancellable>()
 
     private weak var module: FocusableViewModule?
@@ -22,9 +26,9 @@ public class FocusableView: ParallaxView {
 
     @MainActor private weak var focusableGroup: FocusableGroupProtocol?
 
-    @objc public var onViewFocus: RCTBubblingEventBlock?
-    @objc public var onViewPress: RCTBubblingEventBlock?
-    @objc public var onViewBlur: RCTBubblingEventBlock?
+    @objc public var onViewFocus: RCTDirectEventBlock?
+    @objc public var onViewPress: RCTDirectEventBlock?
+    @objc public var onViewBlur: RCTDirectEventBlock?
     @objc public var isParallaxDisabled: Bool = false {
         didSet {
             parallaxEffectOptions.parallaxMotionEffect.isDisabled = isParallaxDisabled

package/package.json

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