@erkamyaman/capacitor-foldable 7.0.0

package/ios/Sources/FoldablePlugin/Foldable.swift

@@ -0,0 +1,156 @@
+import Foundation
+import UIKit
+
+struct NativeFold {
+    var state: String
+    var isSeparating: Bool
+    var hingeOrientation: String?
+    var hingeBounds: CGRect?
+    var occludedBounds: CGRect?
+    var activeDisplay: String?
+    var cameraBounds: [CGRect] = []
+}
+
+protocol FoldProvider {
+    var isFoldable: Bool { get }
+    var supportsTabletop: Bool { get }
+    func fold(in view: UIView?) -> NativeFold?
+    func hingeAngle() -> Double?
+    func observe(_ view: UIView, onChange: @escaping () -> Void)
+}
+
+struct UnsupportedFoldProvider: FoldProvider {
+    var isFoldable: Bool { false }
+    var supportsTabletop: Bool { false }
+
+    func fold(in view: UIView?) -> NativeFold? {
+        return nil
+    }
+
+    func hingeAngle() -> Double? {
+        return nil
+    }
+
+    func observe(_ view: UIView, onChange: @escaping () -> Void) {}
+}
+
+@objc public class Foldable: NSObject {
+    private let provider: FoldProvider
+
+    init(provider: FoldProvider) {
+        self.provider = provider
+        super.init()
+    }
+
+    override public convenience init() {
+        self.init(provider: Foldable.defaultProvider())
+    }
+
+    private static func defaultProvider() -> FoldProvider {
+        #if canImport(UIKit, _underlyingVersion: 9127.0.85) && !targetEnvironment(macCatalyst)
+        if #available(iOS 27.1, *) {
+            return ReservedRegionFoldProvider(source: UIKitFoldSource())
+        }
+        #endif
+        return UnsupportedFoldProvider()
+    }
+
+    @objc public func isDeviceFoldable() -> Bool {
+        return provider.isFoldable
+    }
+
+    @objc public func supportsTabletop() -> Bool {
+        return provider.supportsTabletop
+    }
+
+    public func getFoldState(in view: UIView? = nil) -> [String: Any] {
+        guard let fold = provider.fold(in: view) else {
+            return ["state": "flat", "isSeparating": false, "posture": "flat"]
+        }
+
+        var result: [String: Any] = [
+            "state": fold.state,
+            "isSeparating": fold.isSeparating,
+            "posture": posture(of: fold)
+        ]
+        result["hingeOrientation"] = fold.hingeOrientation
+        result["hingeBounds"] = fold.hingeBounds.map(bounds(of:))
+        result["occludedBounds"] = fold.occludedBounds.map(bounds(of:))
+        result["activeDisplay"] = fold.activeDisplay
+        if !fold.cameraBounds.isEmpty {
+            result["cameraBounds"] = fold.cameraBounds.map(bounds(of:))
+        }
+        return result
+    }
+
+    @objc public func getHingeAngle() -> [String: Any] {
+        return ["angle": provider.hingeAngle().map { $0 as Any } ?? NSNull()]
+    }
+
+    @objc public func barPlacement(in traits: UITraitCollection) -> [String: Any] {
+        return ["verticalBarEdge": verticalBarEdge(of: traits).map { $0 as Any } ?? NSNull()]
+    }
+
+    private func verticalBarEdge(of traits: UITraitCollection) -> String? {
+        #if canImport(UIKit, _underlyingVersion: 9127.0.85) && !targetEnvironment(macCatalyst)
+        if #available(iOS 27.1, *) {
+            switch traits.verticalBarEdge {
+            case .leading: return "leading"
+            case .trailing: return "trailing"
+            default: return nil
+            }
+        }
+        #endif
+        return nil
+    }
+
+    public func observeChanges(in view: UIView, onChange: @escaping () -> Void) {
+        provider.observe(view, onChange: onChange)
+    }
+
+    @objc public func sizeClass(
+        horizontal: UIUserInterfaceSizeClass,
+        vertical: UIUserInterfaceSizeClass,
+        width: CGFloat,
+        height: CGFloat
+    ) -> [String: String] {
+        return [
+            "horizontal": name(of: horizontal),
+            "vertical": name(of: vertical),
+            "widthClass": widthClass(of: width),
+            "heightClass": heightClass(of: height)
+        ]
+    }
+
+    private func name(of sizeClass: UIUserInterfaceSizeClass) -> String {
+        return sizeClass == .regular ? "regular" : "compact"
+    }
+
+    private func widthClass(of width: CGFloat) -> String {
+        if width >= 1600 { return "extraLarge" }
+        if width >= 1200 { return "large" }
+        if width >= 840 { return "expanded" }
+        if width >= 600 { return "medium" }
+        return "compact"
+    }
+
+    private func heightClass(of height: CGFloat) -> String {
+        if height >= 900 { return "expanded" }
+        if height >= 480 { return "medium" }
+        return "compact"
+    }
+
+    private func posture(of fold: NativeFold) -> String {
+        guard fold.state == "half-opened" else { return "flat" }
+        return fold.hingeOrientation == "horizontal" ? "tabletop" : "book"
+    }
+
+    private func bounds(of rect: CGRect) -> [String: Int] {
+        return [
+            "x": Int(rect.origin.x.rounded()),
+            "y": Int(rect.origin.y.rounded()),
+            "width": Int(rect.size.width.rounded()),
+            "height": Int(rect.size.height.rounded())
+        ]
+    }
+}

package/ios/Sources/FoldablePlugin/FoldablePlugin.swift

@@ -0,0 +1,194 @@
+import Foundation
+import UIKit
+import Capacitor
+
+/**
+ * Please read the Capacitor iOS Plugin Development Guide
+ * here: https://capacitorjs.com/docs/plugins/ios
+ */
+@objc(FoldablePlugin)
+public class FoldablePlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "FoldablePlugin"
+    public let jsName = "Foldable"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "isDeviceFoldable", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getFoldState", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getHingeAngle", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSizeClass", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDisplayModes", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getBarPlacement", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startRearDisplay", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopRearDisplay", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startDualScreen", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopDualScreen", returnType: CAPPluginReturnPromise)
+    ]
+    private let implementation = Foldable()
+    private var lastSizeClass: [String: String]?
+    private var lastFoldState: [String: Any]?
+    private var lastBarPlacement: [String: Any]?
+    private var lastHingeAngle: Double?
+    private var orientationObserver: NSObjectProtocol?
+
+    @objc override public func load() {
+        DispatchQueue.main.async { [weak self] in
+            self?.observeChanges()
+        }
+    }
+
+    deinit {
+        if let orientationObserver = orientationObserver {
+            NotificationCenter.default.removeObserver(orientationObserver)
+            UIDevice.current.endGeneratingDeviceOrientationNotifications()
+        }
+    }
+
+    @objc func isDeviceFoldable(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            call.resolve([
+                "foldable": self.implementation.isDeviceFoldable(),
+                "supportsTabletop": self.implementation.supportsTabletop()
+            ])
+        }
+    }
+
+    @objc func getFoldState(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            call.resolve(self.currentFoldState())
+        }
+    }
+
+    @objc func getHingeAngle(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            call.resolve(self.implementation.getHingeAngle())
+        }
+    }
+
+    @objc func getSizeClass(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            call.resolve(self.currentSizeClass())
+        }
+    }
+
+    @objc func getDisplayModes(_ call: CAPPluginCall) {
+        call.resolve(["rearDisplay": "unsupported", "dualScreen": "unsupported"])
+    }
+
+    @objc func getBarPlacement(_ call: CAPPluginCall) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            call.resolve(self.currentBarPlacement())
+        }
+    }
+
+    @objc func startRearDisplay(_ call: CAPPluginCall) {
+        call.unavailable("Rear display mode is only available on Android.")
+    }
+
+    @objc func stopRearDisplay(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    @objc func startDualScreen(_ call: CAPPluginCall) {
+        call.unavailable("Dual-screen mode is only available on Android.")
+    }
+
+    @objc func stopDualScreen(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func currentFoldState() -> [String: Any] {
+        return implementation.getFoldState(in: bridge?.webView)
+    }
+
+    private func currentBarPlacement() -> [String: Any] {
+        return implementation.barPlacement(in: bridge?.viewController?.traitCollection ?? UITraitCollection.current)
+    }
+
+    private func currentSizeClass() -> [String: String] {
+        let traits = bridge?.viewController?.traitCollection ?? UITraitCollection.current
+        let size = bridge?.viewController?.view.bounds.size ?? .zero
+        return implementation.sizeClass(
+            horizontal: traits.horizontalSizeClass,
+            vertical: traits.verticalSizeClass,
+            width: size.width,
+            height: size.height
+        )
+    }
+
+    private func observeChanges() {
+        guard let view = bridge?.viewController?.view else { return }
+
+        lastFoldState = currentFoldState()
+        lastBarPlacement = currentBarPlacement()
+        implementation.observeChanges(in: view) { [weak self] in
+            self?.notifyFoldStateIfChanged()
+            self?.notifyHingeAngleIfChanged()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+                self?.notifyFoldStateIfChanged()
+            }
+        }
+
+        UIDevice.current.beginGeneratingDeviceOrientationNotifications()
+        orientationObserver = NotificationCenter.default.addObserver(
+            forName: UIDevice.orientationDidChangeNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.notifyFoldStateIfChanged()
+            self?.notifySizeClassIfChanged()
+            self?.notifyBarPlacementIfChanged()
+        }
+
+        guard #available(iOS 17.0, *) else { return }
+
+        lastSizeClass = currentSizeClass()
+        MainActor.assumeIsolated {
+            var traits: [UITrait] = [UITraitHorizontalSizeClass.self, UITraitVerticalSizeClass.self]
+            #if canImport(UIKit, _underlyingVersion: 9127.0.85) && !targetEnvironment(macCatalyst)
+            if #available(iOS 27.1, *) {
+                traits += UITraitCollection.systemTraitsAffectingVerticalBarEdge
+            }
+            #endif
+            _ = view.registerForTraitChanges(traits) { [weak self] (_: UIView, _: UITraitCollection) in
+                self?.notifySizeClassIfChanged()
+                self?.notifyFoldStateIfChanged()
+                self?.notifyBarPlacementIfChanged()
+            }
+        }
+    }
+
+    private func notifyHingeAngleIfChanged() {
+        guard let angle = implementation.getHingeAngle()["angle"] as? Double, angle != lastHingeAngle else { return }
+
+        lastHingeAngle = angle
+        notifyListeners("hingeAngleChange", data: ["angle": angle])
+    }
+
+    private func notifyBarPlacementIfChanged() {
+        let placement = currentBarPlacement()
+        if let last = lastBarPlacement, (last as NSDictionary).isEqual(to: placement) { return }
+
+        lastBarPlacement = placement
+        notifyListeners("barPlacementChange", data: placement)
+    }
+
+    private func notifyFoldStateIfChanged() {
+        let foldState = currentFoldState()
+        if let last = lastFoldState, (last as NSDictionary).isEqual(to: foldState) { return }
+
+        lastFoldState = foldState
+        notifyListeners("foldStateChange", data: foldState)
+    }
+
+    private func notifySizeClassIfChanged() {
+        let sizeClass = currentSizeClass()
+        guard sizeClass != lastSizeClass else { return }
+
+        lastSizeClass = sizeClass
+        notifyListeners("sizeClassChange", data: sizeClass)
+    }
+}

package/ios/Sources/FoldablePlugin/ReservedRegionFoldProvider.swift

@@ -0,0 +1,69 @@
+import UIKit
+
+struct ReservedRegion {
+    enum Kind {
+        case division
+        case occlusion
+    }
+
+    var kind: Kind
+    var frame: CGRect
+    var isActive: Bool
+}
+
+enum HingeStatus {
+    case closed
+    case partiallyOpen
+    case fullyOpen
+}
+
+protocol FoldSource {
+    var hasFold: Bool { get }
+    var hingeStatus: HingeStatus? { get }
+    var hingeAngle: Double? { get }
+    func reservedRegions(in view: UIView) -> [ReservedRegion]
+    func observe(_ view: UIView, onChange: @escaping () -> Void)
+}
+
+struct ReservedRegionFoldProvider: FoldProvider {
+    let source: FoldSource
+
+    var isFoldable: Bool { source.hasFold }
+    var supportsTabletop: Bool { source.hasFold }
+
+    func fold(in view: UIView?) -> NativeFold? {
+        guard source.hasFold, let view = view else { return nil }
+        return nativeFoldOf(regions: source.reservedRegions(in: view), hingeStatus: source.hingeStatus)
+    }
+
+    func hingeAngle() -> Double? {
+        return source.hingeAngle
+    }
+
+    func observe(_ view: UIView, onChange: @escaping () -> Void) {
+        source.observe(view, onChange: onChange)
+    }
+}
+
+func nativeFoldOf(regions: [ReservedRegion], hingeStatus: HingeStatus?) -> NativeFold {
+    let divisions = hingeStatus == .closed ? [] : regions.filter { $0.kind == .division }
+    let division = divisions.first { $0.isActive } ?? divisions.first
+    let isFolded: Bool
+    switch hingeStatus {
+    case .partiallyOpen?:
+        isFolded = division != nil
+    case .fullyOpen?:
+        isFolded = false
+    default:
+        isFolded = division?.isActive == true
+    }
+
+    var fold = NativeFold(state: isFolded ? "half-opened" : "flat", isSeparating: isFolded)
+    if let division = division {
+        fold.hingeBounds = division.frame
+        fold.hingeOrientation = division.frame.height >= division.frame.width ? "vertical" : "horizontal"
+    }
+    fold.cameraBounds = regions.filter { $0.kind == .occlusion && $0.isActive }.map { $0.frame }
+    fold.activeDisplay = hingeStatus.map { $0 == .closed ? "outer" : "inner" }
+    return fold
+}

package/ios/Sources/FoldablePlugin/UIKitFoldSource.swift

@@ -0,0 +1,53 @@
+import UIKit
+
+#if canImport(UIKit, _underlyingVersion: 9127.0.85) && !targetEnvironment(macCatalyst)
+@available(iOS 27.1, *)
+@MainActor
+final class UIKitFoldSource: @preconcurrency FoldSource {
+    private weak var view: UIView?
+    private var interaction: UIHingeInteraction?
+    private var hinge: (status: UIHinge.Status, angle: CGFloat)?
+
+    nonisolated init() {}
+
+    var hasFold: Bool {
+        if let status = hinge?.status, status != .unknown { return true }
+        guard let view = view else { return false }
+        return !view.reservedRegions(kind: .division, options: .includeInactive).isEmpty
+    }
+
+    var hingeStatus: HingeStatus? {
+        switch hinge?.status {
+        case .closed: return .closed
+        case .partiallyOpen: return .partiallyOpen
+        case .fullyOpen: return .fullyOpen
+        default: return nil
+        }
+    }
+
+    var hingeAngle: Double? {
+        guard let hinge = hinge, hinge.status != .unknown else { return nil }
+        return Double(hinge.angle) * 180 / .pi
+    }
+
+    func reservedRegions(in view: UIView) -> [ReservedRegion] {
+        let divisions = view.reservedRegions(kind: .division, options: .includeInactive).map {
+            ReservedRegion(kind: .division, frame: $0.frame, isActive: $0.isActive)
+        }
+        let occlusions = view.reservedRegions(kind: .occlusion).map {
+            ReservedRegion(kind: .occlusion, frame: $0.frame, isActive: $0.isActive)
+        }
+        return divisions + occlusions
+    }
+
+    func observe(_ view: UIView, onChange: @escaping () -> Void) {
+        self.view = view
+        let interaction = UIHingeInteraction { [weak self] _, update in
+            self?.hinge = update.hinge.map { ($0.status, $0.angle) }
+            onChange()
+        }
+        view.addInteraction(interaction)
+        self.interaction = interaction
+    }
+}
+#endif

package/ios/Tests/FoldablePluginTests/FoldableTests.swift

@@ -0,0 +1,104 @@
+import UIKit
+import XCTest
+@testable import FoldablePlugin
+
+private final class FakeFoldProvider: FoldProvider {
+    var isFoldable = true
+    var supportsTabletop = true
+    var reportedFold: NativeFold?
+    var angle: Double?
+
+    func fold(in view: UIView?) -> NativeFold? {
+        return reportedFold
+    }
+
+    func hingeAngle() -> Double? {
+        return angle
+    }
+
+    func observe(_ view: UIView, onChange: @escaping () -> Void) {}
+}
+
+class FoldableTests: XCTestCase {
+    func testIsDeviceFoldableReportsFalseStub() {
+        let implementation = Foldable()
+
+        XCTAssertFalse(implementation.isDeviceFoldable())
+        XCTAssertFalse(implementation.supportsTabletop())
+    }
+
+    func testGetFoldStateReportsFlatStub() {
+        let result = Foldable().getFoldState()
+
+        XCTAssertEqual(result["state"] as? String, "flat")
+        XCTAssertEqual(result["isSeparating"] as? Bool, false)
+        XCTAssertEqual(result["posture"] as? String, "flat")
+        XCTAssertNil(result["hingeOrientation"])
+        XCTAssertNil(result["occludedBounds"])
+    }
+
+    func testSizeClassNamesUIKitSizeClassesAndWindowClasses() {
+        let result = Foldable().sizeClass(horizontal: .regular, vertical: .regular, width: 626, height: 890)
+
+        XCTAssertEqual(result["horizontal"], "regular")
+        XCTAssertEqual(result["vertical"], "regular")
+        XCTAssertEqual(result["widthClass"], "medium")
+        XCTAssertEqual(result["heightClass"], "medium")
+    }
+
+    func testBarPlacementIsHorizontalWithoutVerticalBars() {
+        XCTAssertTrue(Foldable().barPlacement(in: UITraitCollection())["verticalBarEdge"] is NSNull)
+    }
+
+    func testGetHingeAngleReportsNullStub() {
+        XCTAssertTrue(Foldable().getHingeAngle()["angle"] is NSNull)
+    }
+
+    func testGetFoldStateMapsProviderFold() {
+        let provider = FakeFoldProvider()
+        provider.reportedFold = NativeFold(
+            state: "half-opened",
+            isSeparating: true,
+            hingeOrientation: "vertical",
+            hingeBounds: CGRect(x: 400.4, y: 0, width: 20, height: 700),
+            activeDisplay: "inner",
+            cameraBounds: [CGRect(x: 10, y: 10, width: 40, height: 40)]
+        )
+
+        let result = Foldable(provider: provider).getFoldState()
+
+        XCTAssertEqual(result["state"] as? String, "half-opened")
+        XCTAssertEqual(result["isSeparating"] as? Bool, true)
+        XCTAssertEqual(result["posture"] as? String, "book")
+        XCTAssertEqual(result["hingeOrientation"] as? String, "vertical")
+        XCTAssertEqual(result["hingeBounds"] as? [String: Int], ["x": 400, "y": 0, "width": 20, "height": 700])
+        XCTAssertNil(result["occludedBounds"])
+        XCTAssertEqual(result["activeDisplay"] as? String, "inner")
+        XCTAssertEqual(result["cameraBounds"] as? [[String: Int]], [["x": 10, "y": 10, "width": 40, "height": 40]])
+    }
+
+    func testHorizontalHalfOpenedFoldIsTabletop() {
+        let provider = FakeFoldProvider()
+        provider.reportedFold = NativeFold(state: "half-opened", isSeparating: true, hingeOrientation: "horizontal")
+
+        XCTAssertEqual(Foldable(provider: provider).getFoldState()["posture"] as? String, "tabletop")
+    }
+
+    func testFoldStateOmitsCameraBoundsWhenThereAreNone() {
+        let provider = FakeFoldProvider()
+        provider.reportedFold = NativeFold(state: "flat", isSeparating: false)
+
+        XCTAssertNil(Foldable(provider: provider).getFoldState()["cameraBounds"])
+    }
+
+    func testIsDeviceFoldableAndHingeAngleReadProvider() {
+        let provider = FakeFoldProvider()
+        provider.angle = 90
+
+        let implementation = Foldable(provider: provider)
+
+        XCTAssertTrue(implementation.isDeviceFoldable())
+        XCTAssertTrue(implementation.supportsTabletop())
+        XCTAssertEqual(implementation.getHingeAngle()["angle"] as? Double, 90)
+    }
+}