@applicaster/quick-brick-native-apple 5.20.5 → 5.20.7

package/apple/QuickBrickApple.podspec.json

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

package/apple/ios/Extensions/ReactNativeOrientation+Extensions.swift

@@ -0,0 +1,62 @@
+//
+//  ReactNativeOrientation+Extensions.swift
+//  QuickBrickApple
+//
+//  Created by Anna Bauza on 03/02/2020.
+//
+
+import UIKit
+import ZappCore
+
+public extension ReactNativeOrientation {
+    static func fromInterfaceOrientation(orientation: UIInterfaceOrientation) -> ReactNativeOrientation {
+        switch orientation {
+        case .portrait:
+            return .portrait
+        case .landscapeLeft:
+            return .landscapeLeft
+        case .landscapeRight:
+            return .landscapeRight
+        case .portraitUpsideDown:
+            return .portraitUpsideDown
+        default:
+            return .unknown
+        }
+    }
+
+    static func fromDeviceOrientation(orientation: UIDeviceOrientation) -> ReactNativeOrientation {
+        switch orientation {
+        case .portrait:
+            return .portrait
+        case .landscapeLeft:
+            return .landscapeRight
+        case .landscapeRight:
+            return .landscapeLeft
+        case .portraitUpsideDown:
+            return .portraitUpsideDown
+        default:
+            return .unknown
+        }
+    }
+
+    func toInterfaceOrientationMask() -> UIInterfaceOrientationMask {
+        switch self {
+        case .portrait:
+            return .portrait
+        case .landscapeLeft:
+            return .landscapeLeft
+        case .landscapeRight:
+            return .landscapeRight
+        case .landscape:
+            return .landscape
+        case .portraitUpsideDown:
+            return .portraitUpsideDown
+        case .all:
+            return .all
+        case .allButUpsideDown:
+            return .allButUpsideDown
+        default:
+            return .portrait
+        }
+    }
+}

package/apple/ios/Extensions/UIInterfaceOrientationMask+ReactNative.swift

@@ -0,0 +1,33 @@
+//
+//  UIInterfaceOrientationMask+ReactNative.swift
+//  QuickBrickApple
+//
+//  Created by Anton Kononenko on 10/11/22.
+//
+
+import Foundation
+
+extension UIInterfaceOrientationMask {
+    func toString() -> String {
+        switch self {
+        case .portrait:
+            return "portrait"
+        case .landscapeRight:
+            return "landscapeRight"
+        case .landscapeLeft:
+            return "landscapeLeft"
+        case .landscape:
+            return "landscape"
+        case .portraitUpsideDown:
+            return "portraitUpsideDown"
+        case .portrait:
+            return "portrait"
+        case .all:
+            return "all"
+        case .allButUpsideDown:
+            return "allButUpsideDown"
+        default:
+            return "all"
+        }
+    }
+}

package/apple/ios/ReactNative/QuickBrickViewController.swift

@@ -17,7 +17,6 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
     }
 
     lazy var logger = Logger.getLogger(for: QuickBrickViewControllerLogs.subsystem)
-    var currentOrientation: UIDeviceOrientation = .unknown
 
     var orientationStack = [UIInterfaceOrientationMask.all]
     var orientationMask: UIInterfaceOrientationMask = QuickBrickViewController.initialOrientationMask
@@ -26,6 +25,10 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         orientationMask
     }
 
+    override var prefersHomeIndicatorAutoHidden: Bool {
+        homeIndicatorAutoHidden
+    }
+
     override public var shouldAutorotate: Bool {
         true
     }
@@ -51,6 +54,7 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         return value.boolValue
     }
 
+    var currentInterfaceOrientation: UIInterfaceOrientation = .unknown
     func getUIOrientation() -> UIInterfaceOrientation {
         guard let interfaceOrientation = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation else {
             return .unknown
@@ -58,67 +62,42 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         return interfaceOrientation
     }
 
-    func getUIOrientationMappedToDeviceOrientation() -> UIDeviceOrientation {
-        let interfaceOrientation = getUIOrientation()
-
-        switch interfaceOrientation {
-        case .landscapeLeft:
-            return .landscapeLeft
-        case .landscapeRight:
-            return .landscapeRight
-        case .portrait:
-            return .portrait
-        case .portraitUpsideDown:
-            return .portraitUpsideDown
-        default:
-            return .unknown
-        }
-    }
-
+    var currentDeviceOrientation: UIDeviceOrientation = .unknown
     func getDeviceOrientation() -> UIDeviceOrientation {
-        let deviceOrientation = UIDevice.current.orientation
-        if deviceOrientation == .landscapeLeft {
-            return .landscapeRight
-        } else if deviceOrientation == .landscapeRight {
-            return .landscapeLeft
-        }
-
-        return deviceOrientation
+        UIDevice.current.orientation
     }
 
-    /// Allow Orientation for specific screen
-    ///
-    /// - Parameters:
-    ///   - orientation: int value representing
-    ///         JS_PORTAIT = 1
-    ///         JS_LANDSCAPE = 1
-    ///         JS_LANDSCAPE_REVERSED = 4
-    ///         JS_PORTAIT_REVERSED = 8
-    ///         JS_LANDSCAPE_SENSOR = JS_LANDSCAPE | JS_LANDSCAPE_REVERSED
-    ///         JS_PORTAIT_SENSOR = JS_PORTAIT | JS_PORTAIT_REVERSED
-    ///         JS_FULL_SENSOR = JS_LANDSCAPE_SENSOR | JS_PORTAIT_SENSOR
-    ///         JS_SENSOR = JS_LANDSCAPE_SENSOR | JS_PORTAIT
-    public func allowOrientationForScreen(_ orientation: Int) {
-        orientationMask = mapOrientation(orientation)
+    public func allowOrientationForScreen(_ orientation: ReactNativeOrientation) {
+        orientationMask = orientation.toInterfaceOrientationMask()
+        // TODO: Remove orientation stack
         orientationStack.append(orientationMask)
-        forceOrientationIfNeeded(orientationMask: orientationMask)
+        forceOrientationWithMaskIfNeeded(orientationMask)
     }
 
     /// Release Orientation for specific screen to previous state
     public func releaseOrientationForScreen() {
         if orientationStack.count > 1 {
             _ = orientationStack.dropLast()
-            forceOrientationIfNeeded(orientationMask: orientationStack.last ?? UIInterfaceOrientationMask.all)
+            forceOrientationWithMaskIfNeeded(orientationStack.last ?? UIInterfaceOrientationMask.all)
         }
     }
 
-    override func viewWillTransition(to _: CGSize,
-                                     with _: UIViewControllerTransitionCoordinator) {
-        let orientation = getUIOrientationMappedToDeviceOrientation()
+    override func viewWillTransition(to size: CGSize,
+                                     with coordinator: UIViewControllerTransitionCoordinator) {
+        super.viewWillTransition(to: size, with: coordinator)
+        let isLandscape = size.width > size.height
+        let interfaceOrientation = isLandscape ?
+            UIInterfaceOrientation.landscapeLeft :
+            UIInterfaceOrientation.portrait
 
-        ReactNativeEventEmitter.orientationChange(toOrientation: orientation,
-                                                  fromOrientation: currentOrientation)
-        logger?.debugLog(message: "viewWillTransition: ui orientation was change to: \(orientation.toString())",
+        let reactNativeToOrientation = ReactNativeOrientation.fromInterfaceOrientation(orientation: interfaceOrientation)
+        let reactNativefromOrientation = ReactNativeOrientation.fromInterfaceOrientation(orientation: currentInterfaceOrientation)
+        currentInterfaceOrientation = interfaceOrientation
+
+        ReactNativeEventEmitter.orientationChange(toOrientation: reactNativeToOrientation,
+                                                  fromOrientation: reactNativefromOrientation)
+
+        logger?.debugLog(message: "viewWillTransition: interface orientation was changed to: \(interfaceOrientation.toString())",
                          category: QuickBrickViewControllerLogs.forceOrientation.category)
     }
 
@@ -129,9 +108,13 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
                                                selector: #selector(deviceDidRotate(notification:)),
                                                name: UIDevice.orientationDidChangeNotification,
                                                object: nil)
+    }
 
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
         // Initial device orientation
-        currentOrientation = UIDevice.current.orientation
+        currentDeviceOrientation = getDeviceOrientation()
+        currentInterfaceOrientation = getUIOrientation()
     }
 
     override func viewWillDisappear(_ animated: Bool) {
@@ -152,112 +135,65 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
             return
         }
 
-        ReactNativeEventEmitter.orientationChange(toOrientation: deviceOrientation,
-                                                  fromOrientation: currentOrientation,
+        let reactNativeToOrientation = ReactNativeOrientation.fromDeviceOrientation(orientation: deviceOrientation)
+        let reactNativeFromOrientation = ReactNativeOrientation.fromDeviceOrientation(orientation: currentDeviceOrientation)
+        currentDeviceOrientation = deviceOrientation
+
+        ReactNativeEventEmitter.orientationChange(toOrientation: reactNativeToOrientation,
+                                                  fromOrientation: reactNativeFromOrientation,
                                                   physicalChange: true)
-        logger?.debugLog(message: "deviceDidRotate: UI oritation changed to: \(getUIOrientation().toString())",
-                         category: QuickBrickViewControllerLogs.forceOrientation.category)
 
-        currentOrientation = deviceOrientation
+        logger?.debugLog(message: "deviceDidRotate: device oritation changed to: \(deviceOrientation.toString())",
+                         category: QuickBrickViewControllerLogs.forceOrientation.category)
     }
 
-    private func mapOrientation(_ orientation: Int) -> UIInterfaceOrientationMask {
-        let JS_PORTAIT = 0x0000_0001
-        let JS_LANDSCAPE = 0x0000_0002 // landscapeRight: 2,
-        let JS_LANDSCAPE_REVERSED = 0x0000_0004
-        let JS_PORTAIT_REVERSED = 0x0000_0008
-        let JS_LANDSCAPE_SENSOR = JS_LANDSCAPE | JS_LANDSCAPE_REVERSED
-        let JS_PORTAIT_SENSOR = JS_PORTAIT | JS_PORTAIT_REVERSED
-        let JS_FULL_SENSOR = JS_LANDSCAPE_SENSOR | JS_PORTAIT_SENSOR
-        let JS_SENSOR = JS_LANDSCAPE_SENSOR | JS_PORTAIT
-
-        switch orientation {
-        case JS_PORTAIT:
-            return UIInterfaceOrientationMask.portrait
-        case JS_LANDSCAPE:
-            return UIInterfaceOrientationMask.landscapeRight
-        case JS_LANDSCAPE_REVERSED:
-            return UIInterfaceOrientationMask.landscapeLeft
-        case JS_LANDSCAPE_SENSOR:
-            return UIInterfaceOrientationMask.landscape
-        case JS_PORTAIT_REVERSED:
-            return UIInterfaceOrientationMask.portraitUpsideDown
-        case JS_PORTAIT_SENSOR:
-            return UIInterfaceOrientationMask.portrait
-        case JS_FULL_SENSOR:
-            return UIInterfaceOrientationMask.all
-        case JS_SENSOR:
-            return UIInterfaceOrientationMask.allButUpsideDown
-        default:
-            return UIInterfaceOrientationMask.all
+    private func forceOrientationWithMaskIfNeeded(_ orientationMask: UIInterfaceOrientationMask) {
+        if #available(iOS 16.0, *) {
+            logger?.debugLog(message: "\(QuickBrickViewControllerLogs.forceOrientation.message) UI orientation to: \(orientationMask.toString())",
+                             category: QuickBrickViewControllerLogs.forceOrientation.category)
+
+            let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
+            windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: orientationMask))
+            UIViewController.attemptRotationToDeviceOrientation()
+            return
         }
-    }
 
-    private func mapOrientationMask(_ orientationMask: UIInterfaceOrientationMask) -> UIInterfaceOrientation {
-        switch orientationMask {
-        case UIInterfaceOrientationMask.portrait:
-            return UIInterfaceOrientation.portrait
-        case UIInterfaceOrientationMask.landscape:
-            return UIInterfaceOrientation.landscapeRight
-        case UIInterfaceOrientationMask.landscapeRight:
-            return UIInterfaceOrientation.landscapeRight
-        case UIInterfaceOrientationMask.landscapeLeft:
-            return UIInterfaceOrientation.landscapeLeft
-        case UIInterfaceOrientationMask.all:
-            return UIInterfaceOrientation.portrait
-        case UIInterfaceOrientationMask.allButUpsideDown:
-            return UIInterfaceOrientation.portrait
-        case UIInterfaceOrientationMask.portraitUpsideDown:
-            return UIInterfaceOrientation.portraitUpsideDown
-        default:
-            return UIInterfaceOrientation.portrait
+        if isSupportOrientation(mask: orientationMask,
+                                interfaceOrientation: currentInterfaceOrientation) {
+            return
         }
+
+        logger?.debugLog(message: "\(QuickBrickViewControllerLogs.forceOrientation.message) UI orientation to: \(orientationMask.toString())",
+                         category: QuickBrickViewControllerLogs.forceOrientation.category)
+
+        changeOrienation(orientationMask: orientationMask)
     }
 
-    private func forceOrientationIfNeeded(orientationMask: UIInterfaceOrientationMask) {
-        let interfaceOrientation = getUIOrientation()
-        switch orientationMask {
-        case UIInterfaceOrientationMask.portrait:
-            forceOrientation(UIInterfaceOrientation.portrait)
-        case UIInterfaceOrientationMask.landscape:
+    func changeOrienation(orientationMask: UIInterfaceOrientationMask) {
+        func setDeviceOrientation(_ orientaion: UIDeviceOrientation) {
+            UIDevice.current.setValue(orientaion.rawValue,
+                                      forKey: "orientation")
+        }
 
-            if interfaceOrientation == .landscapeRight {
-                forceOrientation(UIInterfaceOrientation.landscapeRight)
+        if orientationMask == .landscapeRight {
+            setDeviceOrientation(UIDeviceOrientation.landscapeLeft)
+        } else if orientationMask == .landscapeLeft {
+            setDeviceOrientation(UIDeviceOrientation.landscapeRight)
+        } else if orientationMask == .landscape {
+            if currentDeviceOrientation == .landscapeLeft || currentDeviceOrientation == .landscapeRight {
+                setDeviceOrientation(currentDeviceOrientation)
             } else {
-                forceOrientation(UIInterfaceOrientation.landscapeLeft)
+                setDeviceOrientation(UIDeviceOrientation.landscapeRight)
             }
 
-        case UIInterfaceOrientationMask.landscapeRight:
-            forceOrientation(UIInterfaceOrientation.landscapeRight)
-
-        case UIInterfaceOrientationMask.landscapeLeft:
-            forceOrientation(UIInterfaceOrientation.landscapeLeft)
-
-        case UIInterfaceOrientationMask.all:
-            break
-        case UIInterfaceOrientationMask.allButUpsideDown:
-            forceOrientation(UIInterfaceOrientation.portrait)
-
-        case UIInterfaceOrientationMask.portraitUpsideDown:
-            forceOrientation(UIInterfaceOrientation.portraitUpsideDown)
-        default:
-            break
+        } else if orientationMask == .portrait {
+            setDeviceOrientation(UIDeviceOrientation.portrait)
         }
-    }
 
-    private func forceOrientation(_ orientation: UIInterfaceOrientation) {
-        if let newOrientation = UIDeviceOrientation(rawValue: orientation.rawValue) {
-            logger?.debugLog(message: "\(QuickBrickViewControllerLogs.forceOrientation.message) UI oritation to: \(orientation.toString())",
-                             category: QuickBrickViewControllerLogs.forceOrientation.category,
-                             data: ["newDeviceOrientation": newOrientation.toString(),
-                                    "newInterfaceOrientation": orientation.toString()])
-            UIDevice.current.setValue(newOrientation,
-                                      forKey: "orientation")
-            UIViewController.attemptRotationToDeviceOrientation()
-        }
+        UIViewController.attemptRotationToDeviceOrientation()
     }
 
-    override var prefersHomeIndicatorAutoHidden: Bool {
-        homeIndicatorAutoHidden
+    func isSupportOrientation(mask: UIInterfaceOrientationMask, interfaceOrientation: UIInterfaceOrientation) -> Bool {
+        (mask.rawValue & (1 << interfaceOrientation.rawValue)) != 0
     }
 }

package/apple/ios/ReactNativeEventEmitter.swift

@@ -2,7 +2,7 @@
 //  ReactNativeEventEmitter.swift
 //  QuickBrickApple
 //
-//  Created by Pawel Buderaski on 24/08/2021.
+//  Created by Anton Kononenko on 10/11/2022.
 //
 
 import Foundation
@@ -12,12 +12,12 @@ import React
 open class ReactNativeEventEmitter: RCTEventEmitter {
     public static var emitter: RCTEventEmitter!
 
-    public static func orientationChange(toOrientation: UIDeviceOrientation,
-                                         fromOrientation: UIDeviceOrientation,
+    public static func orientationChange(toOrientation: ReactNativeOrientation,
+                                         fromOrientation: ReactNativeOrientation,
                                          physicalChange: Bool = false) {
         if toOrientation.rawValue > 0 {
-            emitter?.sendEvent(withName: "orientationChange", body: ["toOrientation": toOrientation.mapOrientation(),
-                                                                     "fromOrientation": fromOrientation.mapOrientation(),
+            emitter?.sendEvent(withName: "orientationChange", body: ["toOrientation": toOrientation.rawValue,
+                                                                     "fromOrientation": fromOrientation.rawValue,
                                                                      "physicalChange": physicalChange])
         }
     }

package/apple/universal/Models/ReactNativeOrientation.swift

@@ -0,0 +1,20 @@
+//
+//  ReactNativeOrientation.swift
+//  QuickBrickApple
+//
+//  Created by Anna Bauza on 03/02/2020.
+//
+
+import UIKit
+import ZappCore
+
+public enum ReactNativeOrientation: Int {
+    case unknown = 0
+    case portrait = 1
+    case landscapeRight = 2
+    case landscapeLeft = 4
+    case portraitUpsideDown = 8
+    case landscape = 6
+    case all = 15
+    case allButUpsideDown = 7
+}

package/apple/universal/ReactNative/ReactNativeManager.swift

@@ -200,8 +200,10 @@ extension ReactNativeManager: QuickBrickManagerDelegate {
     }
 
     public func allowOrientationForScreen(_ payload: [String: Any]) {
-        if let qbViewController = reactNativeViewController() as? QuickBrickViewController, let orientation = payload["orientation"] as? Int {
-            qbViewController.allowOrientationForScreen(orientation)
+        if let qbViewController = reactNativeViewController() as? QuickBrickViewController,
+           let orientation = payload["orientation"] as? Int,
+           let reactNativeOrientation = ReactNativeOrientation(rawValue: orientation) {
+            qbViewController.allowOrientationForScreen(reactNativeOrientation)
         }
     }
 

package/package.json

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

package/apple/ios/Extensions/UIDeviceOrientation+Extension.swift

@@ -1,31 +0,0 @@
-//
-//  UIDeviceOrientation+Extension.swift
-//  QuickBrickApple
-//
-//  Created by Anton Kononenko on 8/30/21.
-//  Copyright © 2021 Anton Kononenko. All rights reserved.
-//
-
-import Foundation
-import React
-
-extension UIDeviceOrientation {
-    func mapOrientation() -> Int {
-        var orientation = 0
-
-        switch self {
-        case .portrait:
-            orientation = 1
-        case .landscapeRight:
-            orientation = 2
-        case .landscapeLeft:
-            orientation = 4
-        case .portraitUpsideDown:
-            orientation = 8
-        default:
-            orientation = 0
-        }
-
-        return orientation
-    }
-}