@capawesome/capacitor-pixlive 0.0.1

package/ios/Plugin/PixlivePlugin.swift

@@ -0,0 +1,503 @@
+import AVFoundation
+import CoreBluetooth
+import CoreLocation
+import Foundation
+import UIKit
+import UserNotifications
+import Capacitor
+
+@objc(PixlivePlugin)
+// swiftlint:disable:next type_body_length
+public class PixlivePlugin: CAPPlugin, CAPBridgedPlugin, CLLocationManagerDelegate {
+    public let identifier = "PixlivePlugin"
+    public let jsName = "Pixlive"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "initialize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "synchronize", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "synchronizeWithToursAndContexts", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "updateTagMapping", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "enableContextsWithTags", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getContexts", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getContext", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "activateContext", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopContext", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getNearbyGPSPoints", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getGPSPointsInBoundingBox", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getNearbyBeacons", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startNearbyGPSDetection", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopNearbyGPSDetection", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startGPSNotifications", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopGPSNotifications", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setNotificationsSupport", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setInterfaceLanguage", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "createARView", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "destroyARView", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "resizeARView", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setARViewTouchEnabled", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setARViewTouchHole", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getVersion", returnType: CAPPluginReturnPromise)
+    ]
+
+    public static let tag = "Pixlive"
+
+    private var implementation: Pixlive?
+    private var locationManager: CLLocationManager?
+    private var locationPermissionCallback: (() -> Void)?
+
+    override public func load() {
+        implementation = Pixlive(self)
+    }
+
+    @objc func initialize(_ call: CAPPluginCall) {
+        implementation?.initialize(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        var result = JSObject()
+        result["bluetooth"] = mapBluetoothPermissionState()
+        result["camera"] = mapCameraPermissionState()
+        result["location"] = mapLocationPermissionState()
+        result["notifications"] = "prompt"
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            result["notifications"] = self.mapNotificationPermissionState(settings.authorizationStatus)
+            call.resolve(result)
+        }
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        let permissions = call.getArray("permissions", String.self) ?? ["bluetooth", "camera", "location", "notifications"]
+        let group = DispatchGroup()
+
+        if permissions.contains("camera") {
+            group.enter()
+            AVCaptureDevice.requestAccess(for: .video) { _ in
+                group.leave()
+            }
+        }
+
+        if permissions.contains("location") {
+            group.enter()
+            DispatchQueue.main.async {
+                if self.locationManager == nil {
+                    self.locationManager = CLLocationManager()
+                }
+                self.locationManager?.delegate = self
+                let status = CLLocationManager.authorizationStatus()
+                if status != .notDetermined {
+                    group.leave()
+                } else {
+                    self.locationPermissionCallback = {
+                        group.leave()
+                    }
+                    self.locationManager?.requestAlwaysAuthorization()
+                }
+            }
+        }
+
+        if permissions.contains("notifications") {
+            group.enter()
+            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { _, _ in
+                group.leave()
+            }
+        }
+
+        group.notify(queue: .main) {
+            self.checkPermissions(call)
+        }
+    }
+
+    @objc func synchronize(_ call: CAPPluginCall) {
+        do {
+            let options = try SynchronizeOptions(call)
+            implementation?.synchronize(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func synchronizeWithToursAndContexts(_ call: CAPPluginCall) {
+        do {
+            let options = try SynchronizeWithToursAndContextsOptions(call)
+            implementation?.synchronizeWithToursAndContexts(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func updateTagMapping(_ call: CAPPluginCall) {
+        do {
+            let options = try UpdateTagMappingOptions(call)
+            implementation?.updateTagMapping(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func enableContextsWithTags(_ call: CAPPluginCall) {
+        do {
+            let options = try EnableContextsWithTagsOptions(call)
+            implementation?.enableContextsWithTags(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func getContexts(_ call: CAPPluginCall) {
+        implementation?.getContexts(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call, result)
+            }
+        })
+    }
+
+    @objc func getContext(_ call: CAPPluginCall) {
+        do {
+            let options = try GetContextOptions(call)
+            implementation?.getContext(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func activateContext(_ call: CAPPluginCall) {
+        do {
+            let options = try ActivateContextOptions(call)
+            implementation?.activateContext(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func stopContext(_ call: CAPPluginCall) {
+        implementation?.stopContext(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc func getNearbyGPSPoints(_ call: CAPPluginCall) {
+        do {
+            let options = try GetNearbyGPSPointsOptions(call)
+            implementation?.getNearbyGPSPoints(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func getGPSPointsInBoundingBox(_ call: CAPPluginCall) {
+        do {
+            let options = try GetGPSPointsInBoundingBoxOptions(call)
+            implementation?.getGPSPointsInBoundingBox(options, completion: { result, error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call, result)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func getNearbyBeacons(_ call: CAPPluginCall) {
+        implementation?.getNearbyBeacons(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call, result)
+            }
+        })
+    }
+
+    @objc func startNearbyGPSDetection(_ call: CAPPluginCall) {
+        implementation?.startNearbyGPSDetection(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc func stopNearbyGPSDetection(_ call: CAPPluginCall) {
+        implementation?.stopNearbyGPSDetection(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc func startGPSNotifications(_ call: CAPPluginCall) {
+        implementation?.startGPSNotifications(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc func stopGPSNotifications(_ call: CAPPluginCall) {
+        implementation?.stopGPSNotifications(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc func setNotificationsSupport(_ call: CAPPluginCall) {
+        do {
+            let options = try SetNotificationsSupportOptions(call)
+            implementation?.setNotificationsSupport(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setInterfaceLanguage(_ call: CAPPluginCall) {
+        do {
+            let options = try SetInterfaceLanguageOptions(call)
+            implementation?.setInterfaceLanguage(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func createARView(_ call: CAPPluginCall) {
+        do {
+            let options = try CreateARViewOptions(call)
+            implementation?.createARView(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func destroyARView(_ call: CAPPluginCall) {
+        implementation?.destroyARView(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        })
+    }
+
+    @objc func resizeARView(_ call: CAPPluginCall) {
+        do {
+            let options = try ResizeARViewOptions(call)
+            implementation?.resizeARView(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setARViewTouchEnabled(_ call: CAPPluginCall) {
+        do {
+            let options = try SetARViewTouchEnabledOptions(call)
+            implementation?.setARViewTouchEnabled(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func setARViewTouchHole(_ call: CAPPluginCall) {
+        do {
+            let options = try SetARViewTouchHoleOptions(call)
+            implementation?.setARViewTouchHole(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                } else {
+                    self.resolveCall(call)
+                }
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+    
+    @objc func getVersion(_ call: CAPPluginCall) {
+        implementation?.getVersion(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call, result)
+            }
+        })
+    }
+
+    public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        let status = CLLocationManager.authorizationStatus()
+        if status == .notDetermined {
+            return
+        }
+        if let callback = locationPermissionCallback {
+            locationPermissionCallback = nil
+            callback()
+        }
+    }
+
+    public func notifyListenersFromImplementation(_ eventName: String, data: JSObject) {
+        notifyListeners(eventName, data: data)
+    }
+
+    private func mapBluetoothPermissionState() -> String {
+        if #available(iOS 13.1, *) {
+            switch CBCentralManager.authorization {
+            case .allowedAlways:
+                return "granted"
+            case .denied, .restricted:
+                return "denied"
+            case .notDetermined:
+                return "prompt"
+            @unknown default:
+                return "prompt"
+            }
+        }
+        return "granted"
+    }
+
+    private func mapLocationPermissionState() -> String {
+        switch CLLocationManager.authorizationStatus() {
+        case .authorizedAlways, .authorizedWhenInUse:
+            return "granted"
+        case .denied, .restricted:
+            return "denied"
+        case .notDetermined:
+            return "prompt"
+        @unknown default:
+            return "prompt"
+        }
+    }
+
+    private func mapCameraPermissionState() -> String {
+        switch AVCaptureDevice.authorizationStatus(for: .video) {
+        case .authorized:
+            return "granted"
+        case .denied, .restricted:
+            return "denied"
+        case .notDetermined:
+            return "prompt"
+        @unknown default:
+            return "prompt"
+        }
+    }
+
+    private func mapNotificationPermissionState(_ status: UNAuthorizationStatus) -> String {
+        switch status {
+        case .authorized, .provisional, .ephemeral:
+            return "granted"
+        case .denied:
+            return "denied"
+        case .notDetermined:
+            return "prompt"
+        @unknown default:
+            return "prompt"
+        }
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", PixlivePlugin.tag, "] ", error)
+        call.reject(error.localizedDescription)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,6 @@
+import Foundation
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/ios/Plugin/TouchForwarderView.swift

@@ -0,0 +1,24 @@
+import UIKit
+
+class TouchForwarderView: UIView {
+
+    var touchEnabled = false
+    var touchHole: CGRect?
+    weak var arView: UIView?
+
+    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
+        guard touchEnabled, let arView = arView, arView.superview != nil, !arView.isHidden else {
+            return true
+        }
+        let arPoint = convert(point, to: arView)
+        if touchHole != nil && touchHole!.contains(arPoint) {
+            return true
+        }
+        if arPoint.x >= 0 && arPoint.y >= 0
+            && arPoint.x < arView.frame.size.width
+            && arPoint.y < arView.frame.size.height {
+            return false
+        }
+        return true
+    }
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@capawesome/capacitor-pixlive",
+  "version": "0.0.1",
+  "description": "Unofficial Capacitor plugin for Pixlive SDK.",
+  "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/",
+    "CapawesomeCapacitorPixlive.podspec",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "if [ \"$CI\" = \"true\" ]; then echo 'Skipping iOS verify (SDK not available in CI)'; else cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..; fi",
+    "verify:android": "if [ \"$CI\" = \"true\" ]; then echo 'Skipping Android verify (SDK not available in CI)'; else cd android && ./gradlew clean build test && cd ..; fi",
+    "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 PixlivePlugin --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",
+    "ios:pod:install": "cd ios && pod install --repo-update && cd ..",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "@ionic/swiftlint-config": "2.0.0",
+    "eslint": "8.57.0",
+    "prettier": "3.4.2",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}