@capawesome/capacitor-screen-orientation 1.1.7-dev.36f3183.1659623993

package/ios/Plugin/ScreenOrientation.swift

@@ -0,0 +1,141 @@
+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:
+            let isPortrait = UIApplication.shared.statusBarOrientation.isPortrait
+            return isPortrait ? "portrait-primary" : "landscape-primary"
+        }
+    }
+}

package/ios/Plugin/ScreenOrientationPlugin.h

@@ -0,0 +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>
+

package/ios/Plugin/ScreenOrientationPlugin.m

@@ -0,0 +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);
+)

package/ios/Plugin/ScreenOrientationPlugin.swift

@@ -0,0 +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
+        ])
+    }
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@capawesome/capacitor-screen-orientation",
+  "version": "1.1.7-dev.36f3183.1659623993",
+  "description": "Capacitor plugin to lock/unlock the screen orientation.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "CapawesomeCapacitorScreenOrientation.podspec"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-screen-orientation.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-screen-orientation/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api ScreenOrientationPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.js",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "release": "standard-version"
+  },
+  "devDependencies": {
+    "@capacitor/android": "4.0.1",
+    "@capacitor/cli": "4.0.1",
+    "@capacitor/core": "4.0.1",
+    "@capacitor/docgen": "0.2.0",
+    "@capacitor/ios": "4.0.1",
+    "@ionic/eslint-config": "0.3.0",
+    "@ionic/prettier-config": "1.0.1",
+    "@ionic/swiftlint-config": "1.1.2",
+    "eslint": "7.32.0",
+    "prettier": "2.3.2",
+    "prettier-plugin-java": "1.0.2",
+    "rimraf": "3.0.2",
+    "rollup": "2.77.2",
+    "standard-version": "9.5.0",
+    "swiftlint": "1.0.1",
+    "typescript": "4.1.5"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^4.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}