@applicaster/quick-brick-native-apple 5.20.4 → 5.20.6

package/apple/QuickBrickApple.podspec.json

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

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 = UIDevice.current.orientation
 
     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
     }
@@ -47,146 +50,150 @@ class QuickBrickViewController: UIViewController, UILayerViewControllerProtocol
         else {
             return false
         }
+
         return value.boolValue
     }
 
-    /// 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)
+    var currentInterfaceOrientation: UIInterfaceOrientation = .unknown
+    func getUIOrientation() -> UIInterfaceOrientation {
+        guard let interfaceOrientation = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation else {
+            return .unknown
+        }
+        return interfaceOrientation
+    }
+
+    var currentDeviceOrientation: UIDeviceOrientation = .unknown
+    func getDeviceOrientation() -> UIDeviceOrientation {
+        UIDevice.current.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) {
-        ReactNativeEventEmitter.orientationChange(toOrientation: UIDevice.current.orientation, fromOrientation: currentOrientation)
-        currentOrientation = UIDevice.current.orientation
+    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
+
+        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)
     }
 
     override func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
-        currentOrientation = UIDevice.current.orientation
-    }
-
-    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
+        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(deviceDidRotate(notification:)),
+                                               name: UIDevice.orientationDidChangeNotification,
+                                               object: nil)
+    }
+
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        // Initial device orientation
+        currentDeviceOrientation = getDeviceOrientation()
+        currentInterfaceOrientation = getUIOrientation()
+    }
+
+    override func viewWillDisappear(_ animated: Bool) {
+        super.viewWillDisappear(animated)
+        NotificationCenter.default.removeObserver(self)
+        if UIDevice.current.isGeneratingDeviceOrientationNotifications {
+            UIDevice.current.endGeneratingDeviceOrientationNotifications()
         }
     }
 
-    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
+    @objc func deviceDidRotate(notification _: NSNotification) {
+        let deviceOrientation = getDeviceOrientation()
+
+        // In this cases we does not want to send notifications
+        if deviceOrientation == .unknown ||
+            deviceOrientation == .faceDown ||
+            deviceOrientation == .faceUp {
+            return
         }
+
+        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: device oritation changed to: \(deviceOrientation.toString())",
+                         category: QuickBrickViewControllerLogs.forceOrientation.category)
     }
 
-    private func forceOrientationIfNeeded(orientationMask: UIInterfaceOrientationMask) {
-        switch orientationMask {
-        case UIInterfaceOrientationMask.portrait:
-            if !UIDevice.current.orientation.isPortrait {
-                forceOrientation(UIInterfaceOrientation.portrait)
-            }
-        case UIInterfaceOrientationMask.landscape:
-            if !UIDevice.current.orientation.isLandscape {
-                let statusBarOrientation = UIApplication.shared.statusBarOrientation
-                if statusBarOrientation == UIInterfaceOrientation.landscapeLeft {
-                    forceOrientation(UIInterfaceOrientation.landscapeLeft)
-                } else {
-                    forceOrientation(UIInterfaceOrientation.landscapeRight)
-                }
-            }
-        case UIInterfaceOrientationMask.landscapeRight:
-            if UIDevice.current.orientation.rawValue != UIInterfaceOrientation.landscapeRight.rawValue {
-                forceOrientation(UIInterfaceOrientation.landscapeRight)
-            }
-        case UIInterfaceOrientationMask.landscapeLeft:
-            if UIDevice.current.orientation.rawValue != UIInterfaceOrientation.landscapeLeft.rawValue {
-                forceOrientation(UIInterfaceOrientation.landscapeLeft)
-            }
-        case UIInterfaceOrientationMask.all:
-            break
-        case UIInterfaceOrientationMask.allButUpsideDown:
-            if !UIDevice.current.orientation.isLandscape, UIDevice.current.orientation.rawValue != UIInterfaceOrientation.portrait.rawValue {
-                forceOrientation(UIInterfaceOrientation.portrait)
-            }
-        case UIInterfaceOrientationMask.portraitUpsideDown:
-            if UIDevice.current.orientation.rawValue != UIInterfaceOrientation.portraitUpsideDown.rawValue {
-                forceOrientation(UIInterfaceOrientation.portraitUpsideDown)
-            }
-        default:
-            break
+    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
         }
+
+        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 forceOrientation(_ orientation: UIInterfaceOrientation) {
-        logger?.debugLog(message: QuickBrickViewControllerLogs.forceOrientation.message,
-                         category: QuickBrickViewControllerLogs.forceOrientation.category,
-                         data: ["orientation": "\(orientation.rawValue)"])
+    func changeOrienation(orientationMask: UIInterfaceOrientationMask) {
+        func setDeviceOrientation(_ orientaion: UIDeviceOrientation) {
+            UIDevice.current.setValue(orientaion.rawValue,
+                                      forKey: "orientation")
+        }
+
+        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 {
+                setDeviceOrientation(UIDeviceOrientation.landscapeRight)
+            }
+
+        } else if orientationMask == .portrait {
+            setDeviceOrientation(UIDeviceOrientation.portrait)
+        }
 
-        UIDevice.current.setValue(orientation.rawValue, forKey: "orientation")
         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,9 +12,13 @@ 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/ios/ReactNativeOrientation.swift

@@ -0,0 +1,71 @@
+//
+//  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
+
+    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/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.4",
+  "version": "5.20.6",
   "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
-    }
-}