@capgo/capacitor-screen-orientation 7.0.0

package/dist/plugin.js

@@ -0,0 +1,98 @@
+var capacitorScreenOrientation = (function (exports, core) {
+    'use strict';
+
+    const ScreenOrientation = core.registerPlugin('CapacitorScreenOrientation', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.CapacitorScreenOrientationWeb()),
+    });
+
+    class CapacitorScreenOrientationWeb extends core.WebPlugin {
+        constructor() {
+            var _a;
+            super();
+            this.pluginVersion = '1.0.0';
+            if ((_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation) {
+                window.screen.orientation.addEventListener('change', () => {
+                    this.notifyListeners('screenOrientationChange', {
+                        type: this.mapOrientationType(window.screen.orientation.type),
+                    });
+                });
+            }
+        }
+        async orientation() {
+            var _a;
+            if (!((_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation)) {
+                throw this.unavailable('Screen Orientation API not available');
+            }
+            return {
+                type: this.mapOrientationType(window.screen.orientation.type),
+            };
+        }
+        async lock(options) {
+            var _a;
+            const screenOrientation = (_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation;
+            if (!(screenOrientation === null || screenOrientation === void 0 ? void 0 : screenOrientation.lock)) {
+                throw this.unavailable('Screen Orientation lock not available');
+            }
+            // bypassOrientationLock is only supported on iOS native platform
+            // Silently ignore it on web
+            try {
+                await screenOrientation.lock(options.orientation);
+            }
+            catch (error) {
+                throw new Error(`Failed to lock orientation: ${error}`);
+            }
+        }
+        async unlock() {
+            var _a;
+            const screenOrientation = (_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation;
+            if (!(screenOrientation === null || screenOrientation === void 0 ? void 0 : screenOrientation.unlock)) {
+                throw this.unavailable('Screen Orientation unlock not available');
+            }
+            screenOrientation.unlock();
+        }
+        async startOrientationTracking(_options) {
+            // Motion-based orientation tracking is only supported on iOS
+            // Silently ignore on web
+        }
+        async stopOrientationTracking() {
+            // Motion-based orientation tracking is only supported on iOS
+            // Silently ignore on web
+        }
+        async isOrientationLocked() {
+            const orientationResult = await this.orientation();
+            return {
+                locked: false,
+                uiOrientation: orientationResult.type,
+            };
+        }
+        async getPluginVersion() {
+            return { version: this.pluginVersion };
+        }
+        mapOrientationType(type) {
+            if (type.includes('portrait-primary') || type === 'portrait-primary') {
+                return 'portrait-primary';
+            }
+            if (type.includes('portrait-secondary') || type === 'portrait-secondary') {
+                return 'portrait-secondary';
+            }
+            if (type.includes('landscape-primary') || type === 'landscape-primary') {
+                return 'landscape-primary';
+            }
+            if (type.includes('landscape-secondary') || type === 'landscape-secondary') {
+                return 'landscape-secondary';
+            }
+            return 'portrait-primary'; // default fallback
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        CapacitorScreenOrientationWeb: CapacitorScreenOrientationWeb
+    });
+
+    exports.ScreenOrientation = ScreenOrientation;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst ScreenOrientation = registerPlugin('CapacitorScreenOrientation', {\n    web: () => import('./web').then((m) => new m.CapacitorScreenOrientationWeb()),\n});\nexport * from './definitions';\nexport { ScreenOrientation };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class CapacitorScreenOrientationWeb extends WebPlugin {\n    constructor() {\n        var _a;\n        super();\n        this.pluginVersion = '1.0.0';\n        if ((_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation) {\n            window.screen.orientation.addEventListener('change', () => {\n                this.notifyListeners('screenOrientationChange', {\n                    type: this.mapOrientationType(window.screen.orientation.type),\n                });\n            });\n        }\n    }\n    async orientation() {\n        var _a;\n        if (!((_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation)) {\n            throw this.unavailable('Screen Orientation API not available');\n        }\n        return {\n            type: this.mapOrientationType(window.screen.orientation.type),\n        };\n    }\n    async lock(options) {\n        var _a;\n        const screenOrientation = (_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation;\n        if (!(screenOrientation === null || screenOrientation === void 0 ? void 0 : screenOrientation.lock)) {\n            throw this.unavailable('Screen Orientation lock not available');\n        }\n        // bypassOrientationLock is only supported on iOS native platform\n        // Silently ignore it on web\n        try {\n            await screenOrientation.lock(options.orientation);\n        }\n        catch (error) {\n            throw new Error(`Failed to lock orientation: ${error}`);\n        }\n    }\n    async unlock() {\n        var _a;\n        const screenOrientation = (_a = window.screen) === null || _a === void 0 ? void 0 : _a.orientation;\n        if (!(screenOrientation === null || screenOrientation === void 0 ? void 0 : screenOrientation.unlock)) {\n            throw this.unavailable('Screen Orientation unlock not available');\n        }\n        screenOrientation.unlock();\n    }\n    async startOrientationTracking(_options) {\n        // Motion-based orientation tracking is only supported on iOS\n        // Silently ignore on web\n    }\n    async stopOrientationTracking() {\n        // Motion-based orientation tracking is only supported on iOS\n        // Silently ignore on web\n    }\n    async isOrientationLocked() {\n        const orientationResult = await this.orientation();\n        return {\n            locked: false,\n            uiOrientation: orientationResult.type,\n        };\n    }\n    async getPluginVersion() {\n        return { version: this.pluginVersion };\n    }\n    mapOrientationType(type) {\n        if (type.includes('portrait-primary') || type === 'portrait-primary') {\n            return 'portrait-primary';\n        }\n        if (type.includes('portrait-secondary') || type === 'portrait-secondary') {\n            return 'portrait-secondary';\n        }\n        if (type.includes('landscape-primary') || type === 'landscape-primary') {\n            return 'landscape-primary';\n        }\n        if (type.includes('landscape-secondary') || type === 'landscape-secondary') {\n            return 'landscape-secondary';\n        }\n        return 'portrait-primary'; // default fallback\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":"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"}

package/ios/Sources/CapacitorScreenOrientationPlugin/CapacitorScreenOrientationPlugin.swift

@@ -0,0 +1,287 @@
+import Foundation
+import Capacitor
+import CoreMotion
+import UIKit
+
+/**
+ * Capacitor Screen Orientation Plugin
+ *
+ * Provides screen orientation detection and control with support for
+ * bypassing device orientation lock using Core Motion sensors.
+ */
+@objc(CapacitorScreenOrientationPlugin)
+public class CapacitorScreenOrientationPlugin: CAPPlugin, CAPBridgedPlugin {
+    private let pluginVersion: String = "7.0.0"
+    public let identifier = "CapacitorScreenOrientationPlugin"
+    public let jsName = "CapacitorScreenOrientation"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "orientation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "lock", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "unlock", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startOrientationTracking", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopOrientationTracking", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isOrientationLocked", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
+    ]
+
+    private var motionManager: CMMotionManager?
+    private var currentDeviceOrientation: UIDeviceOrientation = .portrait
+    private var isTrackingWithMotion = false
+    private var lastNotifiedOrientation: String?
+
+    override public func load() {
+        // Listen for device orientation changes from system
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.orientationDidChange),
+            name: UIDevice.orientationDidChangeNotification,
+            object: nil
+        )
+
+        // Start monitoring device orientation
+        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+    }
+
+    deinit {
+        stopMotionTracking()
+        UIDevice.current.endGeneratingDeviceOrientationNotifications()
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc private func orientationDidChange() {
+        let orientation = UIDevice.current.orientation
+        if orientation.isValidInterfaceOrientation {
+            notifyOrientationChange(fromDeviceOrientation: orientation)
+        }
+    }
+
+    @objc func orientation(_ call: CAPPluginCall) {
+        let orientationType = getCurrentOrientationType()
+        call.resolve(["type": orientationType])
+    }
+
+    @objc func lock(_ call: CAPPluginCall) {
+        guard let orientationString = call.getString("orientation") else {
+            call.reject("Orientation parameter is required")
+            return
+        }
+
+        let bypassLock = call.getBool("bypassOrientationLock") ?? false
+
+        DispatchQueue.main.async {
+            // Lock the orientation at the app level
+            if let mask = self.getOrientationMask(from: orientationString) {
+                // Note: Actual implementation would need to communicate with AppDelegate
+                // to set the supported interface orientations
+                // For now, we'll just track the preference
+                print("Locking orientation to: \(orientationString)")
+            }
+
+            // Start motion tracking if bypass is requested
+            if bypassLock {
+                self.startMotionTracking()
+            }
+
+            call.resolve()
+        }
+    }
+
+    @objc func unlock(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            // Stop motion tracking
+            self.stopMotionTracking()
+
+            // Unlock orientation at app level
+            print("Unlocking orientation")
+
+            call.resolve()
+        }
+    }
+
+    @objc func startOrientationTracking(_ call: CAPPluginCall) {
+        let bypassLock = call.getBool("bypassOrientationLock") ?? false
+
+        if bypassLock {
+            startMotionTracking()
+        }
+
+        call.resolve()
+    }
+
+    @objc func stopOrientationTracking(_ call: CAPPluginCall) {
+        stopMotionTracking()
+        call.resolve()
+    }
+
+    @objc func isOrientationLocked(_ call: CAPPluginCall) {
+        let uiOrientation = getCurrentOrientationType()
+
+        if isTrackingWithMotion {
+            // We have motion data, compare physical vs UI orientation
+            let physicalOrientation = mapDeviceOrientationToString(currentDeviceOrientation)
+            let locked = physicalOrientation != uiOrientation
+
+            call.resolve([
+                "locked": locked,
+                "physicalOrientation": physicalOrientation,
+                "uiOrientation": uiOrientation
+            ])
+        } else {
+            // No motion tracking active, can't determine if locked
+            // Return false by default, but note that we don't have physical orientation data
+            call.resolve([
+                "locked": false,
+                "uiOrientation": uiOrientation
+            ])
+        }
+    }
+
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve(["version": self.pluginVersion])
+    }
+
+    // MARK: - Core Motion Tracking
+
+    private func startMotionTracking() {
+        guard !isTrackingWithMotion else { return }
+
+        motionManager = CMMotionManager()
+        guard let motionManager = motionManager else { return }
+
+        motionManager.accelerometerUpdateInterval = 0.2
+        motionManager.gyroUpdateInterval = 0.2
+
+        if motionManager.isAccelerometerAvailable {
+            isTrackingWithMotion = true
+
+            motionManager.startAccelerometerUpdates(to: .main) { [weak self] (data, _) in
+                guard let self = self, let data = data else { return }
+
+                let acceleration = data.acceleration
+                let orientation = self.determineOrientation(from: acceleration)
+
+                if orientation != self.currentDeviceOrientation {
+                    self.currentDeviceOrientation = orientation
+                    self.notifyOrientationChange(fromDeviceOrientation: orientation)
+                }
+            }
+
+            print("Started motion-based orientation tracking")
+        } else {
+            print("Accelerometer not available")
+        }
+    }
+
+    private func stopMotionTracking() {
+        guard isTrackingWithMotion else { return }
+
+        motionManager?.stopAccelerometerUpdates()
+        motionManager = nil
+        isTrackingWithMotion = false
+
+        print("Stopped motion-based orientation tracking")
+    }
+
+    private func determineOrientation(from acceleration: CMAcceleration) -> UIDeviceOrientation {
+        let threshold = 0.5
+
+        if acceleration.x < -threshold {
+            return .landscapeRight
+        } else if acceleration.x > threshold {
+            return .landscapeLeft
+        } else if acceleration.y < -threshold {
+            return .portrait
+        } else if acceleration.y > threshold {
+            return .portraitUpsideDown
+        }
+
+        return currentDeviceOrientation
+    }
+
+    // MARK: - Helper Methods
+
+    private func getCurrentOrientationType() -> String {
+        let interfaceOrientation: UIInterfaceOrientation
+
+        if #available(iOS 13.0, *) {
+            interfaceOrientation = UIApplication.shared.windows.first?.windowScene?.interfaceOrientation ?? .portrait
+        } else {
+            interfaceOrientation = UIApplication.shared.statusBarOrientation
+        }
+
+        return mapInterfaceOrientationToString(interfaceOrientation)
+    }
+
+    private func notifyOrientationChange(fromDeviceOrientation deviceOrientation: UIDeviceOrientation) {
+        let orientationType = mapDeviceOrientationToString(deviceOrientation)
+
+        // Only notify if orientation actually changed
+        if orientationType != lastNotifiedOrientation {
+            lastNotifiedOrientation = orientationType
+            notifyListeners("screenOrientationChange", data: ["type": orientationType])
+        }
+    }
+
+    private func mapInterfaceOrientationToString(_ orientation: UIInterfaceOrientation) -> String {
+        switch orientation {
+        case .portrait:
+            return "portrait-primary"
+        case .portraitUpsideDown:
+            return "portrait-secondary"
+        case .landscapeLeft:
+            return "landscape-primary"
+        case .landscapeRight:
+            return "landscape-secondary"
+        default:
+            return "portrait-primary"
+        }
+    }
+
+    private func mapDeviceOrientationToString(_ orientation: UIDeviceOrientation) -> String {
+        switch orientation {
+        case .portrait:
+            return "portrait-primary"
+        case .portraitUpsideDown:
+            return "portrait-secondary"
+        case .landscapeLeft:
+            return "landscape-secondary" // Note: device left = interface right
+        case .landscapeRight:
+            return "landscape-primary" // Note: device right = interface left
+        default:
+            return "portrait-primary"
+        }
+    }
+
+    private func getOrientationMask(from orientationString: String) -> UIInterfaceOrientationMask? {
+        switch orientationString {
+        case "any":
+            return .all
+        case "natural", "portrait":
+            return .portrait
+        case "landscape":
+            return .landscape
+        case "portrait-primary":
+            return .portrait
+        case "portrait-secondary":
+            return .portraitUpsideDown
+        case "landscape-primary":
+            return .landscapeLeft
+        case "landscape-secondary":
+            return .landscapeRight
+        default:
+            return nil
+        }
+    }
+}
+
+// Helper extension
+extension UIDeviceOrientation {
+    var isValidInterfaceOrientation: Bool {
+        switch self {
+        case .portrait, .portraitUpsideDown, .landscapeLeft, .landscapeRight:
+            return true
+        default:
+            return false
+        }
+    }
+}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@capgo/capacitor-screen-orientation",
+  "version": "7.0.0",
+  "description": "Screen orientation plugin with support for bypassing orientation lock",
+  "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/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapgoCapacitorScreenOrientation.podspec"
+  ],
+  "author": "Cap-go <contact@capgo.app>",
+  "license": "MPL-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cap-go/capacitor-screen-orientation.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Cap-go/capacitor-screen-orientation/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "screen",
+    "orientation",
+    "rotation",
+    "portrait",
+    "landscape",
+    "lock",
+    "bypass",
+    "coremotion",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapgoCapacitorScreenOrientation -destination generic/platform=iOS",
+    "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 .",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api CapacitorScreenOrientationPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.0.0",
+    "@capacitor/cli": "^7.0.0",
+    "@capacitor/core": "^7.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^7.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@types/node": "^22.13.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.31.0",
+    "husky": "^9.1.7",
+    "prettier": "^3.4.2",
+    "prettier-plugin-java": "^2.6.7",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.34.6",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}