@capawesome/capacitor-screen-orientation 2.0.1 → 2.0.2

package/ios/Plugin/ScreenOrientation.swift

@@ -1,150 +1,171 @@
-import Foundation
-import UIKit
-
-@objc public class ScreenOrientation: NSObject {
-    static var supportedInterfaceOrientations = UIInterfaceOrientationMask.all
-    private let plugin: ScreenOrientationPlugin
-    private var currentOrientationType: String?
-    private var lastOrientationType: String?
-
-    init(plugin: ScreenOrientationPlugin) {
-        self.plugin = plugin
-        super.init()
-        NotificationCenter.default.addObserver(self, selector: #selector(self.handleOrientationChange), name: UIDevice.orientationDidChangeNotification, object: nil)
-    }
-
-    @objc public static func getSupportedInterfaceOrientations() -> UIInterfaceOrientationMask {
-        return ScreenOrientation.supportedInterfaceOrientations
-    }
-
-    @objc public func lock(_ orientationType: String, completion: @escaping () -> Void) {
-        DispatchQueue.main.async { [weak self] in
-            guard let strongSelf = self else {
-                return
-            }
-            let currentOrientationValue = UIDevice.current.orientation.rawValue
-            let nextOrientationMask = strongSelf.convertOrientationTypeToMask(orientationType)
-            let nextOrientationValue = strongSelf.convertOrientationTypeToValue(orientationType)
-            UIDevice.current.setValue(nextOrientationValue, forKey: "orientation")
-            ScreenOrientation.supportedInterfaceOrientations = nextOrientationMask
-            UINavigationController.attemptRotationToDeviceOrientation()
-            UIDevice.current.setValue(currentOrientationValue, forKey: "orientation")
-            strongSelf.notifyOrientationChangeListeners(orientationType)
-            completion()
-        }
-    }
-
-    @objc public func unlock(completion: @escaping () -> Void) {
-        DispatchQueue.main.async {
-            ScreenOrientation.supportedInterfaceOrientations = UIInterfaceOrientationMask.all
-            UINavigationController.attemptRotationToDeviceOrientation()
-            guard let orientationType = self.lastOrientationType else {
-                return
-            }
-            self.notifyOrientationChangeListeners(orientationType)
-            completion()
-        }
-    }
-
-    @objc public func getCachedCurrentOrientationType(completion: @escaping (String) -> Void) {
-        guard let cachedOrientationType = self.currentOrientationType else {
-            self.getUncachedCurrentOrientationType(completion: completion)
-            return
-        }
-        completion(cachedOrientationType)
-    }
-
-    @objc private func getUncachedCurrentOrientationType(completion: @escaping (String) -> Void) {
-        DispatchQueue.main.async {
-            let orientationValue = UIDevice.current.orientation.rawValue
-            let orientationType = self.convertOrientationValueToType(orientationValue)
-            completion(orientationType)
-        }
-    }
-
-    @objc private func isCurrentOrientationValid() -> Bool {
-        return UIDevice.current.orientation.isValidInterfaceOrientation
-    }
-
-    @objc private func handleOrientationChange() {
-        let isValid = self.isCurrentOrientationValid()
-        guard isValid else {
-            return
-        }
-        self.getUncachedCurrentOrientationType(completion: { orientationType in
-            self.lastOrientationType = orientationType
-            guard ScreenOrientation.supportedInterfaceOrientations == UIInterfaceOrientationMask.all else {
-                return
-            }
-            self.notifyOrientationChangeListeners(orientationType)
-        })
-    }
-
-    @objc private func notifyOrientationChangeListeners(_ orientationType: String) {
-        self.currentOrientationType = orientationType
-        self.plugin.notifyOrientationChangeListeners(orientationType)
-    }
-
-    @objc private func convertOrientationTypeToMask(_ orientationType: String) -> UIInterfaceOrientationMask {
-        switch orientationType {
-        case "landscape":
-            return UIInterfaceOrientationMask.landscapeRight
-        case "landscape-primary":
-            return UIInterfaceOrientationMask.landscapeLeft
-        case "landscape-secondary":
-            return UIInterfaceOrientationMask.landscapeRight
-        case "portrait":
-            return UIInterfaceOrientationMask.portrait
-        case "portrait-primary":
-            return UIInterfaceOrientationMask.portrait
-        case "portrait-secondary":
-            return UIInterfaceOrientationMask.portraitUpsideDown
-        default:
-            return UIInterfaceOrientationMask.all
-        }
-    }
-
-    @objc private func convertOrientationTypeToValue(_ orientationType: String) -> Int {
-        switch orientationType {
-        case "landscape":
-            return UIInterfaceOrientation.landscapeRight.rawValue
-        case "landscape-primary":
-            return UIInterfaceOrientation.landscapeLeft.rawValue
-        case "landscape-secondary":
-            return UIInterfaceOrientation.landscapeRight.rawValue
-        case "portrait":
-            return UIInterfaceOrientation.portrait.rawValue
-        case "portrait-primary":
-            return UIInterfaceOrientation.portrait.rawValue
-        case "portrait-secondary":
-            return UIInterfaceOrientation.portraitUpsideDown.rawValue
-        default:
-            return UIInterfaceOrientation.unknown.rawValue
-        }
-    }
-
-    @objc private func convertOrientationValueToType(_ orientationValue: Int) -> String {
-        switch orientationValue {
-        case UIInterfaceOrientation.landscapeLeft.rawValue:
-            return "landscape-primary"
-        case UIInterfaceOrientation.landscapeRight.rawValue:
-            return "landscape-secondary"
-        case UIInterfaceOrientation.portrait.rawValue:
-            return "portrait-primary"
-        case UIInterfaceOrientation.portraitUpsideDown.rawValue:
-            return "portrait-secondary"
-        default:
-            var isPortrait = false
-            if #available(iOS 13.0, *) {
-              isPortrait = UIApplication.shared.windows
-                .first?
-                .windowScene?
-                .interfaceOrientation
-                .isPortrait ?? false
-            } else {
-              isPortrait = UIApplication.shared.statusBarOrientation.isPortrait
-            }
-            return isPortrait ? "portrait-primary" : "landscape-primary"
-        }
-    }
-}
+import Foundation
+import UIKit
+import Capacitor
+
+@objc public class ScreenOrientation: NSObject {
+    static var supportedInterfaceOrientations = UIInterfaceOrientationMask.all
+    private let plugin: ScreenOrientationPlugin
+    private var currentOrientationType: String?
+    private var lastOrientationType: String?
+
+    init(plugin: ScreenOrientationPlugin) {
+        self.plugin = plugin
+        super.init()
+        NotificationCenter.default.addObserver(self, selector: #selector(self.handleOrientationChange), name: UIDevice.orientationDidChangeNotification, object: nil)
+    }
+
+    @objc public static func getSupportedInterfaceOrientations() -> UIInterfaceOrientationMask {
+        return ScreenOrientation.supportedInterfaceOrientations
+    }
+
+    @objc public func lock(_ orientationType: String, completion: @escaping () -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let strongSelf = self else {
+                return
+            }
+            let currentOrientationValue = UIDevice.current.orientation.rawValue
+            let currentOrientationMask = strongSelf.convertOrientationValueToMask(currentOrientationValue)
+            let nextOrientationMask = strongSelf.convertOrientationTypeToMask(orientationType)
+            let nextOrientationValue = strongSelf.convertOrientationTypeToValue(orientationType)
+            strongSelf.requestGeometryUpdate(orientationValue: nextOrientationValue, orientationMask: nextOrientationMask)
+            ScreenOrientation.supportedInterfaceOrientations = nextOrientationMask
+            UINavigationController.attemptRotationToDeviceOrientation()
+            strongSelf.requestGeometryUpdate(orientationValue: currentOrientationValue, orientationMask: currentOrientationMask)
+            strongSelf.notifyOrientationChangeListeners(orientationType)
+            completion()
+        }
+    }
+
+    @objc public func unlock(completion: @escaping () -> Void) {
+        DispatchQueue.main.async {
+            ScreenOrientation.supportedInterfaceOrientations = UIInterfaceOrientationMask.all
+            UINavigationController.attemptRotationToDeviceOrientation()
+            guard let orientationType = self.lastOrientationType else {
+                return
+            }
+            self.notifyOrientationChangeListeners(orientationType)
+            completion()
+        }
+    }
+
+    @objc public func getCachedCurrentOrientationType(completion: @escaping (String) -> Void) {
+        guard let cachedOrientationType = self.currentOrientationType else {
+            self.getUncachedCurrentOrientationType(completion: completion)
+            return
+        }
+        completion(cachedOrientationType)
+    }
+    
+    @objc private func requestGeometryUpdate(orientationValue: Int, orientationMask: UIInterfaceOrientationMask) {
+        if #available(iOS 16, *) {
+            let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
+            windowScene?.keyWindow?.rootViewController?.setNeedsUpdateOfSupportedInterfaceOrientations()
+            windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: orientationMask)) { error in
+                CAPLog.print("requestGeometryUpdate failed.", error)
+            }
+        } else {
+            UIDevice.current.setValue(orientationValue, forKey: "orientation")
+        }
+    }
+
+    @objc private func getUncachedCurrentOrientationType(completion: @escaping (String) -> Void) {
+        DispatchQueue.main.async {
+            let orientationValue = UIDevice.current.orientation.rawValue
+            let orientationType = self.convertOrientationValueToType(orientationValue)
+            completion(orientationType)
+        }
+    }
+
+    @objc private func isCurrentOrientationValid() -> Bool {
+        return UIDevice.current.orientation.isValidInterfaceOrientation
+    }
+
+    @objc private func handleOrientationChange() {
+        let isValid = self.isCurrentOrientationValid()
+        guard isValid else {
+            return
+        }
+        self.getUncachedCurrentOrientationType(completion: { orientationType in
+            self.lastOrientationType = orientationType
+            guard ScreenOrientation.supportedInterfaceOrientations == UIInterfaceOrientationMask.all else {
+                return
+            }
+            self.notifyOrientationChangeListeners(orientationType)
+        })
+    }
+
+    @objc private func notifyOrientationChangeListeners(_ orientationType: String) {
+        self.currentOrientationType = orientationType
+        self.plugin.notifyOrientationChangeListeners(orientationType)
+    }
+    
+    @objc private func convertOrientationValueToMask(_ orientationValue: Int) -> UIInterfaceOrientationMask {
+        switch orientationValue {
+        case UIInterfaceOrientation.landscapeLeft.rawValue:
+            return UIInterfaceOrientationMask.landscapeLeft
+        case UIInterfaceOrientation.landscapeRight.rawValue:
+            return UIInterfaceOrientationMask.landscapeRight
+        case UIInterfaceOrientation.portrait.rawValue:
+            return UIInterfaceOrientationMask.portrait
+        case UIInterfaceOrientation.portraitUpsideDown.rawValue:
+            return UIInterfaceOrientationMask.portraitUpsideDown
+        default:
+            let isPortrait = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation.isPortrait ?? false
+            return isPortrait ? UIInterfaceOrientationMask.portrait : UIInterfaceOrientationMask.landscapeLeft
+        }
+    }
+
+    @objc private func convertOrientationTypeToMask(_ orientationType: String) -> UIInterfaceOrientationMask {
+        switch orientationType {
+        case "landscape":
+            return UIInterfaceOrientationMask.landscapeRight
+        case "landscape-primary":
+            return UIInterfaceOrientationMask.landscapeLeft
+        case "landscape-secondary":
+            return UIInterfaceOrientationMask.landscapeRight
+        case "portrait":
+            return UIInterfaceOrientationMask.portrait
+        case "portrait-primary":
+            return UIInterfaceOrientationMask.portrait
+        case "portrait-secondary":
+            return UIInterfaceOrientationMask.portraitUpsideDown
+        default:
+            return UIInterfaceOrientationMask.all
+        }
+    }
+
+    @objc private func convertOrientationTypeToValue(_ orientationType: String) -> Int {
+        switch orientationType {
+        case "landscape":
+            return UIInterfaceOrientation.landscapeRight.rawValue
+        case "landscape-primary":
+            return UIInterfaceOrientation.landscapeLeft.rawValue
+        case "landscape-secondary":
+            return UIInterfaceOrientation.landscapeRight.rawValue
+        case "portrait":
+            return UIInterfaceOrientation.portrait.rawValue
+        case "portrait-primary":
+            return UIInterfaceOrientation.portrait.rawValue
+        case "portrait-secondary":
+            return UIInterfaceOrientation.portraitUpsideDown.rawValue
+        default:
+            return UIInterfaceOrientation.unknown.rawValue
+        }
+    }
+
+    @objc private func convertOrientationValueToType(_ orientationValue: Int) -> String {
+        switch orientationValue {
+        case UIInterfaceOrientation.landscapeLeft.rawValue:
+            return "landscape-primary"
+        case UIInterfaceOrientation.landscapeRight.rawValue:
+            return "landscape-secondary"
+        case UIInterfaceOrientation.portrait.rawValue:
+            return "portrait-primary"
+        case UIInterfaceOrientation.portraitUpsideDown.rawValue:
+            return "portrait-secondary"
+        default:
+            let isPortrait = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation.isPortrait ?? false
+            return isPortrait ? "portrait-primary" : "landscape-primary"
+        }
+    }
+}

package/ios/Plugin/ScreenOrientationPlugin.h

@@ -1,10 +1,10 @@
-#import <UIKit/UIKit.h>
-
-//! Project version number for Plugin.
-FOUNDATION_EXPORT double PluginVersionNumber;
-
-//! Project version string for Plugin.
-FOUNDATION_EXPORT const unsigned char PluginVersionString[];
-
-// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
-
+#import <UIKit/UIKit.h>
+
+//! Project version number for Plugin.
+FOUNDATION_EXPORT double PluginVersionNumber;
+
+//! Project version string for Plugin.
+FOUNDATION_EXPORT const unsigned char PluginVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
+

package/ios/Plugin/ScreenOrientationPlugin.m

@@ -1,11 +1,11 @@
-#import <Foundation/Foundation.h>
-#import <Capacitor/Capacitor.h>
-
-// Define the plugin using the CAP_PLUGIN Macro, and
-// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
-CAP_PLUGIN(ScreenOrientationPlugin, "ScreenOrientation",
-           CAP_PLUGIN_METHOD(lock, CAPPluginReturnPromise);
-           CAP_PLUGIN_METHOD(unlock, CAPPluginReturnPromise);
-           CAP_PLUGIN_METHOD(getCurrentOrientation, CAPPluginReturnPromise);
-           CAP_PLUGIN_METHOD(removeAllListeners, CAPPluginReturnNone);
-)
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+// Define the plugin using the CAP_PLUGIN Macro, and
+// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
+CAP_PLUGIN(ScreenOrientationPlugin, "ScreenOrientation",
+           CAP_PLUGIN_METHOD(lock, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(unlock, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(getCurrentOrientation, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(removeAllListeners, CAPPluginReturnNone);
+)

package/ios/Plugin/ScreenOrientationPlugin.swift

@@ -1,47 +1,47 @@
-import Foundation
-import Capacitor
-
-/**
- * Please read the Capacitor iOS Plugin Development Guide
- * here: https://capacitorjs.com/docs/plugins/ios
- */
-@objc(ScreenOrientationPlugin)
-public class ScreenOrientationPlugin: CAPPlugin {
-    public let screenOrientationChangeEvent = "screenOrientationChange"
-    private var implementation: ScreenOrientation?
-
-    override public func load() {
-        self.implementation = ScreenOrientation(plugin: self)
-    }
-
-    deinit {
-        NotificationCenter.default.removeObserver(self)
-    }
-
-    @objc func lock(_ call: CAPPluginCall) {
-        let orientationType = call.getString("type") ?? ""
-        implementation?.lock(orientationType, completion: {
-            call.resolve()
-        })
-    }
-
-    @objc func unlock(_ call: CAPPluginCall) {
-        implementation?.unlock(completion: {
-            call.resolve()
-        })
-    }
-
-    @objc func getCurrentOrientation(_ call: CAPPluginCall) {
-        implementation?.getCachedCurrentOrientationType(completion: { orientationType in
-            call.resolve([
-                "type": orientationType
-            ])
-        })
-    }
-
-    @objc func notifyOrientationChangeListeners(_ orientationType: String) {
-        self.notifyListeners(self.screenOrientationChangeEvent, data: [
-            "type": orientationType
-        ])
-    }
-}
+import Foundation
+import Capacitor
+
+/**
+ * Please read the Capacitor iOS Plugin Development Guide
+ * here: https://capacitorjs.com/docs/plugins/ios
+ */
+@objc(ScreenOrientationPlugin)
+public class ScreenOrientationPlugin: CAPPlugin {
+    public let screenOrientationChangeEvent = "screenOrientationChange"
+    private var implementation: ScreenOrientation?
+
+    override public func load() {
+        self.implementation = ScreenOrientation(plugin: self)
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc func lock(_ call: CAPPluginCall) {
+        let orientationType = call.getString("type") ?? ""
+        implementation?.lock(orientationType, completion: {
+            call.resolve()
+        })
+    }
+
+    @objc func unlock(_ call: CAPPluginCall) {
+        implementation?.unlock(completion: {
+            call.resolve()
+        })
+    }
+
+    @objc func getCurrentOrientation(_ call: CAPPluginCall) {
+        implementation?.getCachedCurrentOrientationType(completion: { orientationType in
+            call.resolve([
+                "type": orientationType
+            ])
+        })
+    }
+
+    @objc func notifyOrientationChangeListeners(_ orientationType: String) {
+        self.notifyListeners(self.screenOrientationChangeEvent, data: [
+            "type": orientationType
+        ])
+    }
+}