@capgo/capacitor-ibeacon 7.0.0

package/ios/Sources/CapacitorIbeaconPlugin/CapacitorIbeacon.swift

@@ -0,0 +1,234 @@
+import Foundation
+import CoreLocation
+import CoreBluetooth
+
+public class CapacitorIbeacon: NSObject, CLLocationManagerDelegate, CBPeripheralManagerDelegate {
+    private var locationManager: CLLocationManager!
+    private var peripheralManager: CBPeripheralManager!
+    private weak var plugin: CapacitorIbeaconPlugin?
+    private var monitoredRegions: [String: CLBeaconRegion] = [:]
+    private var rangedRegions: [String: CLBeaconRegion] = [:]
+
+    public override init() {
+        super.init()
+        locationManager = CLLocationManager()
+        locationManager.delegate = self
+        peripheralManager = CBPeripheralManager(delegate: self, queue: nil)
+    }
+
+    public func setPlugin(_ plugin: CapacitorIbeaconPlugin) {
+        self.plugin = plugin
+    }
+
+    public func startMonitoringForRegion(identifier: String, uuid: String, major: Int?, minor: Int?, completion: @escaping (Result<Void, Error>) -> Void) {
+        guard let beaconUUID = UUID(uuidString: uuid) else {
+            completion(.failure(NSError(domain: "CapacitorIbeacon", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid UUID"])))
+            return
+        }
+
+        let beaconRegion: CLBeaconRegion
+        if let major = major {
+            if let minor = minor {
+                beaconRegion = CLBeaconRegion(uuid: beaconUUID, major: CLBeaconMajorValue(major), minor: CLBeaconMinorValue(minor), identifier: identifier)
+            } else {
+                beaconRegion = CLBeaconRegion(uuid: beaconUUID, major: CLBeaconMajorValue(major), identifier: identifier)
+            }
+        } else {
+            beaconRegion = CLBeaconRegion(uuid: beaconUUID, identifier: identifier)
+        }
+
+        beaconRegion.notifyEntryStateOnDisplay = true
+        beaconRegion.notifyOnEntry = true
+        beaconRegion.notifyOnExit = true
+
+        monitoredRegions[identifier] = beaconRegion
+        locationManager.startMonitoring(for: beaconRegion)
+        completion(.success(()))
+    }
+
+    public func stopMonitoringForRegion(identifier: String, uuid: String) {
+        if let region = monitoredRegions[identifier] {
+            locationManager.stopMonitoring(for: region)
+            monitoredRegions.removeValue(forKey: identifier)
+        }
+    }
+
+    public func startRangingBeaconsInRegion(identifier: String, uuid: String, major: Int?, minor: Int?, completion: @escaping (Result<Void, Error>) -> Void) {
+        guard let beaconUUID = UUID(uuidString: uuid) else {
+            completion(.failure(NSError(domain: "CapacitorIbeacon", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid UUID"])))
+            return
+        }
+
+        let beaconRegion: CLBeaconRegion
+        if let major = major {
+            if let minor = minor {
+                beaconRegion = CLBeaconRegion(uuid: beaconUUID, major: CLBeaconMajorValue(major), minor: CLBeaconMinorValue(minor), identifier: identifier)
+            } else {
+                beaconRegion = CLBeaconRegion(uuid: beaconUUID, major: CLBeaconMajorValue(major), identifier: identifier)
+            }
+        } else {
+            beaconRegion = CLBeaconRegion(uuid: beaconUUID, identifier: identifier)
+        }
+
+        rangedRegions[identifier] = beaconRegion
+        locationManager.startRangingBeacons(in: beaconRegion)
+        completion(.success(()))
+    }
+
+    public func stopRangingBeaconsInRegion(identifier: String, uuid: String) {
+        if let region = rangedRegions[identifier] {
+            locationManager.stopRangingBeacons(in: region)
+            rangedRegions.removeValue(forKey: identifier)
+        }
+    }
+
+    public func startAdvertising(uuid: String, major: Int, minor: Int, identifier: String, measuredPower: Int?, completion: @escaping (Result<Void, Error>) -> Void) {
+        guard let beaconUUID = UUID(uuidString: uuid) else {
+            completion(.failure(NSError(domain: "CapacitorIbeacon", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid UUID"])))
+            return
+        }
+
+        let beaconRegion = CLBeaconRegion(uuid: beaconUUID, major: CLBeaconMajorValue(major), minor: CLBeaconMinorValue(minor), identifier: identifier)
+
+        if let power = measuredPower {
+            peripheralManager.startAdvertising(beaconRegion.peripheralData(withMeasuredPower: NSNumber(value: power)) as? [String: Any])
+        } else {
+            peripheralManager.startAdvertising(beaconRegion.peripheralData(withMeasuredPower: nil) as? [String: Any])
+        }
+
+        completion(.success(()))
+    }
+
+    public func stopAdvertising() {
+        peripheralManager.stopAdvertising()
+    }
+
+    public func requestWhenInUseAuthorization() {
+        locationManager.requestWhenInUseAuthorization()
+    }
+
+    public func requestAlwaysAuthorization() {
+        locationManager.requestAlwaysAuthorization()
+    }
+
+    public func getAuthorizationStatus() -> String {
+        let status = CLLocationManager.authorizationStatus()
+        switch status {
+        case .notDetermined:
+            return "not_determined"
+        case .restricted:
+            return "restricted"
+        case .denied:
+            return "denied"
+        case .authorizedAlways:
+            return "authorized_always"
+        case .authorizedWhenInUse:
+            return "authorized_when_in_use"
+        @unknown default:
+            return "unknown"
+        }
+    }
+
+    public func isBluetoothEnabled() -> Bool {
+        return peripheralManager.state == .poweredOn
+    }
+
+    public func isRangingAvailable() -> Bool {
+        return CLLocationManager.isRangingAvailable()
+    }
+
+    // MARK: - CLLocationManagerDelegate
+
+    public func locationManager(_ manager: CLLocationManager, didRangeBeacons beacons: [CLBeacon], in region: CLBeaconRegion) {
+        var beaconsArray: [[String: Any]] = []
+
+        for beacon in beacons {
+            var proximityString = "unknown"
+            switch beacon.proximity {
+            case .immediate:
+                proximityString = "immediate"
+            case .near:
+                proximityString = "near"
+            case .far:
+                proximityString = "far"
+            case .unknown:
+                proximityString = "unknown"
+            @unknown default:
+                proximityString = "unknown"
+            }
+
+            beaconsArray.append([
+                "uuid": beacon.uuid.uuidString,
+                "major": beacon.major.intValue,
+                "minor": beacon.minor.intValue,
+                "rssi": beacon.rssi,
+                "proximity": proximityString,
+                "accuracy": beacon.accuracy
+            ])
+        }
+
+        plugin?.notifyListeners("didRangeBeacons", data: [
+            "region": [
+                "identifier": region.identifier,
+                "uuid": region.uuid.uuidString
+            ],
+            "beacons": beaconsArray
+        ])
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+        if let beaconRegion = region as? CLBeaconRegion {
+            plugin?.notifyListeners("didEnterRegion", data: [
+                "region": [
+                    "identifier": beaconRegion.identifier,
+                    "uuid": beaconRegion.uuid.uuidString
+                ]
+            ])
+
+            plugin?.notifyListeners("didDetermineStateForRegion", data: [
+                "region": [
+                    "identifier": beaconRegion.identifier,
+                    "uuid": beaconRegion.uuid.uuidString
+                ],
+                "state": "enter"
+            ])
+        }
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+        if let beaconRegion = region as? CLBeaconRegion {
+            plugin?.notifyListeners("didExitRegion", data: [
+                "region": [
+                    "identifier": beaconRegion.identifier,
+                    "uuid": beaconRegion.uuid.uuidString
+                ]
+            ])
+
+            plugin?.notifyListeners("didDetermineStateForRegion", data: [
+                "region": [
+                    "identifier": beaconRegion.identifier,
+                    "uuid": beaconRegion.uuid.uuidString
+                ],
+                "state": "exit"
+            ])
+        }
+    }
+
+    public func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?, withError error: Error) {
+        if let beaconRegion = region as? CLBeaconRegion {
+            plugin?.notifyListeners("monitoringDidFailForRegion", data: [
+                "region": [
+                    "identifier": beaconRegion.identifier,
+                    "uuid": beaconRegion.uuid.uuidString
+                ],
+                "error": error.localizedDescription
+            ])
+        }
+    }
+
+    // MARK: - CBPeripheralManagerDelegate
+
+    public func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
+        // Handle Bluetooth state changes if needed
+    }
+}

package/ios/Sources/CapacitorIbeaconPlugin/CapacitorIbeaconPlugin.swift

@@ -0,0 +1,159 @@
+import Foundation
+import Capacitor
+import CoreLocation
+
+@objc(CapacitorIbeaconPlugin)
+public class CapacitorIbeaconPlugin: CAPPlugin, CAPBridgedPlugin {
+    private let PLUGIN_VERSION: String = "0.0.1"
+    public let identifier = "CapacitorIbeaconPlugin"
+    public let jsName = "CapacitorIbeacon"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "startMonitoringForRegion", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopMonitoringForRegion", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startRangingBeaconsInRegion", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopRangingBeaconsInRegion", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startAdvertising", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopAdvertising", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestWhenInUseAuthorization", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestAlwaysAuthorization", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getAuthorizationStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isBluetoothEnabled", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isRangingAvailable", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
+    ]
+
+    private let implementation = CapacitorIbeacon()
+
+    public override func load() {
+        implementation.setPlugin(self)
+    }
+
+    @objc func startMonitoringForRegion(_ call: CAPPluginCall) {
+        guard let identifier = call.getString("identifier"),
+              let uuid = call.getString("uuid") else {
+            call.reject("Missing required parameters")
+            return
+        }
+
+        implementation.startMonitoringForRegion(
+            identifier: identifier,
+            uuid: uuid,
+            major: call.getInt("major"),
+            minor: call.getInt("minor")
+        ) { result in
+            switch result {
+            case .success:
+                call.resolve()
+            case .failure(let error):
+                call.reject("Failed to start monitoring: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    @objc func stopMonitoringForRegion(_ call: CAPPluginCall) {
+        guard let identifier = call.getString("identifier"),
+              let uuid = call.getString("uuid") else {
+            call.reject("Missing required parameters")
+            return
+        }
+
+        implementation.stopMonitoringForRegion(identifier: identifier, uuid: uuid)
+        call.resolve()
+    }
+
+    @objc func startRangingBeaconsInRegion(_ call: CAPPluginCall) {
+        guard let identifier = call.getString("identifier"),
+              let uuid = call.getString("uuid") else {
+            call.reject("Missing required parameters")
+            return
+        }
+
+        implementation.startRangingBeaconsInRegion(
+            identifier: identifier,
+            uuid: uuid,
+            major: call.getInt("major"),
+            minor: call.getInt("minor")
+        ) { result in
+            switch result {
+            case .success:
+                call.resolve()
+            case .failure(let error):
+                call.reject("Failed to start ranging: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    @objc func stopRangingBeaconsInRegion(_ call: CAPPluginCall) {
+        guard let identifier = call.getString("identifier"),
+              let uuid = call.getString("uuid") else {
+            call.reject("Missing required parameters")
+            return
+        }
+
+        implementation.stopRangingBeaconsInRegion(identifier: identifier, uuid: uuid)
+        call.resolve()
+    }
+
+    @objc func startAdvertising(_ call: CAPPluginCall) {
+        guard let uuid = call.getString("uuid"),
+              let major = call.getInt("major"),
+              let minor = call.getInt("minor"),
+              let identifier = call.getString("identifier") else {
+            call.reject("Missing required parameters")
+            return
+        }
+
+        let measuredPower = call.getInt("measuredPower")
+
+        implementation.startAdvertising(
+            uuid: uuid,
+            major: major,
+            minor: minor,
+            identifier: identifier,
+            measuredPower: measuredPower
+        ) { result in
+            switch result {
+            case .success:
+                call.resolve()
+            case .failure(let error):
+                call.reject("Failed to start advertising: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    @objc func stopAdvertising(_ call: CAPPluginCall) {
+        implementation.stopAdvertising()
+        call.resolve()
+    }
+
+    @objc func requestWhenInUseAuthorization(_ call: CAPPluginCall) {
+        implementation.requestWhenInUseAuthorization()
+        let status = implementation.getAuthorizationStatus()
+        call.resolve(["status": status])
+    }
+
+    @objc func requestAlwaysAuthorization(_ call: CAPPluginCall) {
+        implementation.requestAlwaysAuthorization()
+        let status = implementation.getAuthorizationStatus()
+        call.resolve(["status": status])
+    }
+
+    @objc func getAuthorizationStatus(_ call: CAPPluginCall) {
+        let status = implementation.getAuthorizationStatus()
+        call.resolve(["status": status])
+    }
+
+    @objc func isBluetoothEnabled(_ call: CAPPluginCall) {
+        let enabled = implementation.isBluetoothEnabled()
+        call.resolve(["enabled": enabled])
+    }
+
+    @objc func isRangingAvailable(_ call: CAPPluginCall) {
+        let available = implementation.isRangingAvailable()
+        call.resolve(["available": available])
+    }
+
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve(["version": self.PLUGIN_VERSION])
+    }
+}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@capgo/capacitor-ibeacon",
+  "version": "7.0.0",
+  "description": "iBeacon plugin for Capacitor - proximity detection and beacon region monitoring",
+  "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",
+    "CapgoCapacitorIbeacon.podspec"
+  ],
+  "author": "Martin Donadieu <martin@capgo.app>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cap-go/capacitor-ibeacon.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Cap-go/capacitor-ibeacon/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "ibeacon",
+    "beacon",
+    "bluetooth",
+    "ble",
+    "proximity",
+    "location",
+    "ranging",
+    "monitoring",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapgoCapacitorIbeacon -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 -- --autocorrect --format",
+    "eslint": "eslint .",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api CapacitorIbeaconPlugin --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"
+    }
+  }
+}