@capgo/background-geolocation 8.0.32 → 8.0.34

package/ios/Sources/CapgoBackgroundGeolocationPlugin/CapgoCapacitorBackgroundGeolocationPlugin.swift

@@ -38,7 +38,7 @@ func formatLocation(_ location: CLLocation) -> PluginCallResultData {
 @objc(BackgroundGeolocation)
 // swiftlint:disable:next type_body_length
 public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.0.32"
+    private let pluginVersion: String = "8.0.34"
     public let identifier = "BackgroundGeolocationPlugin"
     public let jsName = "BackgroundGeolocation"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -46,9 +46,15 @@ public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBri
         CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "openSettings", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "setPlannedRoute", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setupGeofencing", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "addGeofence", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeGeofence", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeAllGeofences", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getMonitoredGeofences", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getPluginVersion", returnType: CAPPluginReturnPromise)
     ]
     private var locationManager: CLLocationManager?
+    private var geofenceLocationManager: CLLocationManager?
     private var created: Date?
     private var allowStale: Bool = false
     private var isUpdatingLocation: Bool = false
@@ -57,12 +63,31 @@ public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBri
     private var plannedRoute: [[Double]] = []
     private var isOffRoute: Bool = true
     private var distanceThreshold: Double = 50.0 // Default distance threshold in meters
+    private var geofenceBackendUrl: URL?
+    private var geofenceNotifyOnEntry: Bool = true
+    private var geofenceNotifyOnExit: Bool = true
+    private var geofencePayload: [String: Any] = [:]
+    private var pendingGeofenceSetupCall: CAPPluginCall?
+    private var pendingGeofenceSetupTimeout: DispatchWorkItem?
+    private var pendingGeofenceAddCalls: [String: CAPPluginCall] = [:]
+    private var pendingGeofenceRegions: [String: (region: CLCircularRegion, payload: [String: Any])] = [:]
+    private var lastGeofenceTransition: [String: String] = [:]
+
+    private let geofenceUrlKey = "CapgoBackgroundGeolocation.geofence.url"
+    private let geofenceNotifyOnEntryKey = "CapgoBackgroundGeolocation.geofence.notifyOnEntry"
+    private let geofenceNotifyOnExitKey = "CapgoBackgroundGeolocation.geofence.notifyOnExit"
+    private let geofencePayloadKey = "CapgoBackgroundGeolocation.geofence.payload"
+    private let geofenceRegionPrefix = "CapgoBackgroundGeolocation.geofence.region."
 
     // Earth radius in meters for distance calculations
     private static let earthRadiusMeters: Double = 6371000.0
 
     @objc override public func load() {
         UIDevice.current.isBatteryMonitoringEnabled = true
+        restoreGeofenceConfiguration()
+        DispatchQueue.main.async {
+            _ = self.ensureGeofenceLocationManager()
+        }
     }
 
     @objc func start(_ call: CAPPluginCall) {
@@ -225,6 +250,338 @@ public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBri
         }
     }
 
+    private func requestGeofenceAlwaysAuthorization(_ call: CAPPluginCall, manager: CLLocationManager, status: CLAuthorizationStatus) {
+        pendingGeofenceSetupCall = call
+        pendingGeofenceSetupTimeout?.cancel()
+        let timeout = DispatchWorkItem { [weak self] in
+            guard let self = self, let pendingCall = self.pendingGeofenceSetupCall else { return }
+            self.pendingGeofenceSetupCall = nil
+            self.pendingGeofenceSetupTimeout = nil
+            if manager.authorizationStatus == .authorizedAlways {
+                pendingCall.resolve()
+            } else {
+                pendingCall.reject(
+                    "Always location permission is required for geofencing",
+                    "NOT_AUTHORIZED"
+                )
+            }
+        }
+        pendingGeofenceSetupTimeout = timeout
+        manager.requestAlwaysAuthorization()
+        if status == .authorizedWhenInUse {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 30, execute: timeout)
+        }
+    }
+
+    @objc func setupGeofencing(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            if self.pendingGeofenceSetupCall != nil {
+                return call.reject("A geofence permission request is already in progress", "PERMISSION_REQUEST_IN_PROGRESS")
+            }
+            guard CLLocationManager.isMonitoringAvailable(for: CLCircularRegion.self) else {
+                return call.reject("Geofencing is not available on this device", "NOT_AVAILABLE")
+            }
+            var backendUrl: URL?
+            if let urlString = call.getString("url"), !urlString.isEmpty {
+                guard let url = URL(string: urlString),
+                      let scheme = url.scheme?.lowercased(),
+                      ["http", "https"].contains(scheme) else {
+                    return call.reject("Given url is not valid")
+                }
+                backendUrl = url
+            }
+            let payload = call.getObject("payload") ?? [:]
+            guard JSONSerialization.isValidJSONObject(payload) else {
+                return call.reject("Payload must be valid JSON")
+            }
+
+            self.geofenceBackendUrl = backendUrl
+            self.geofenceNotifyOnEntry = call.getBool("notifyOnEntry") ?? true
+            self.geofenceNotifyOnExit = call.getBool("notifyOnExit") ?? true
+            self.geofencePayload = payload
+            self.persistGeofenceConfiguration()
+
+            let manager = self.ensureGeofenceLocationManager()
+            let status = manager.authorizationStatus
+            if status == .authorizedAlways {
+                return call.resolve()
+            }
+            if call.getBool("requestPermissions") == false {
+                return call.reject("Always location permission is required for geofencing", "NOT_AUTHORIZED")
+            }
+            if [.denied, .restricted].contains(status) {
+                return call.reject("Always location permission is required for geofencing", "NOT_AUTHORIZED")
+            }
+            self.requestGeofenceAlwaysAuthorization(call, manager: manager, status: status)
+        }
+    }
+
+    @objc func addGeofence(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            let manager = self.ensureGeofenceLocationManager()
+            guard self.geofenceAvailable(manager) else {
+                return call.reject("Always location permission is required for geofencing", "NOT_AUTHORIZED")
+            }
+            guard let latitude = call.getDouble("latitude") else {
+                return call.reject("Latitude is required")
+            }
+            guard let longitude = call.getDouble("longitude") else {
+                return call.reject("Longitude is required")
+            }
+            guard let identifier = call.getString("identifier"), !identifier.isEmpty else {
+                return call.reject("Identifier is required")
+            }
+            let radius = call.getDouble("radius") ?? 50.0
+            guard CLLocationCoordinate2DIsValid(CLLocationCoordinate2D(latitude: latitude, longitude: longitude)) else {
+                return call.reject("Invalid latitude or longitude")
+            }
+            guard radius > 0 else {
+                return call.reject("Radius must be greater than 0")
+            }
+            let maximumDistance = manager.maximumRegionMonitoringDistance
+            guard maximumDistance <= 0 || radius <= maximumDistance else {
+                return call.reject("Radius exceeds the maximum supported region monitoring distance")
+            }
+            let notifyOnEntry = call.getBool("notifyOnEntry") ?? self.geofenceNotifyOnEntry
+            let notifyOnExit = call.getBool("notifyOnExit") ?? self.geofenceNotifyOnExit
+            guard notifyOnEntry || notifyOnExit else {
+                return call.reject("At least one transition must be enabled")
+            }
+            let payload = call.getObject("payload") ?? [:]
+            guard JSONSerialization.isValidJSONObject(payload) else {
+                return call.reject("Payload must be valid JSON")
+            }
+
+            guard self.pendingGeofenceAddCalls[identifier] == nil else {
+                return call.reject("A geofence with that identifier is already being added", "PENDING")
+            }
+
+            let center = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+            let region = CLCircularRegion(center: center, radius: radius, identifier: identifier)
+            region.notifyOnEntry = notifyOnEntry
+            region.notifyOnExit = notifyOnExit
+            self.pendingGeofenceAddCalls[identifier] = call
+            self.pendingGeofenceRegions[identifier] = (region, payload)
+            manager.startMonitoring(for: region)
+        }
+    }
+
+    @objc func removeGeofence(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            guard let identifier = call.getString("identifier"), !identifier.isEmpty else {
+                return call.reject("Identifier is required")
+            }
+            let manager = self.ensureGeofenceLocationManager()
+            if let pending = self.pendingGeofenceRegions.removeValue(forKey: identifier) {
+                manager.stopMonitoring(for: pending.region)
+                self.pendingGeofenceAddCalls.removeValue(forKey: identifier)?.reject(
+                    "Geofence was removed before monitoring started",
+                    "CANCELLED"
+                )
+                self.removePersistedGeofenceRegion(identifier)
+                self.lastGeofenceTransition.removeValue(forKey: identifier)
+                return call.resolve()
+            }
+            guard self.persistedGeofenceRegionIds().contains(identifier) else {
+                return call.reject("Could not find a region with that identifier", "NOT_FOUND")
+            }
+            guard let region = manager.monitoredRegions.first(where: { $0.identifier == identifier && $0 is CLCircularRegion }) else {
+                self.pendingGeofenceAddCalls.removeValue(forKey: identifier)?.reject("Geofence was removed before monitoring started", "CANCELLED")
+                self.pendingGeofenceRegions.removeValue(forKey: identifier)
+                self.removePersistedGeofenceRegion(identifier)
+                self.lastGeofenceTransition.removeValue(forKey: identifier)
+                return call.resolve()
+            }
+            manager.stopMonitoring(for: region)
+            self.pendingGeofenceAddCalls.removeValue(forKey: identifier)?.reject("Geofence was removed before monitoring started", "CANCELLED")
+            self.pendingGeofenceRegions.removeValue(forKey: identifier)
+            self.removePersistedGeofenceRegion(identifier)
+            self.lastGeofenceTransition.removeValue(forKey: identifier)
+            call.resolve()
+        }
+    }
+
+    @objc func removeAllGeofences(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            let manager = self.ensureGeofenceLocationManager()
+            let identifiers = self.persistedGeofenceRegionIds()
+            for region in manager.monitoredRegions where region is CLCircularRegion && identifiers.contains(region.identifier) {
+                manager.stopMonitoring(for: region)
+            }
+            for identifier in identifiers {
+                self.removePersistedGeofenceRegion(identifier)
+                self.lastGeofenceTransition.removeValue(forKey: identifier)
+            }
+            for (_, pendingCall) in self.pendingGeofenceAddCalls {
+                pendingCall.reject("Geofences were removed before monitoring started", "CANCELLED")
+            }
+            self.pendingGeofenceAddCalls.removeAll()
+            self.pendingGeofenceRegions.removeAll()
+            call.resolve()
+        }
+    }
+
+    @objc func getMonitoredGeofences(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            let manager = self.ensureGeofenceLocationManager()
+            let identifiers = self.persistedGeofenceRegionIds()
+            let regions = manager.monitoredRegions.compactMap { region -> String? in
+                region is CLCircularRegion && identifiers.contains(region.identifier) ? region.identifier : nil
+            }.sorted()
+            call.resolve(["regions": regions])
+        }
+    }
+
+    private func ensureGeofenceLocationManager() -> CLLocationManager {
+        if let manager = geofenceLocationManager {
+            return manager
+        }
+        let manager = CLLocationManager()
+        manager.delegate = self
+        manager.pausesLocationUpdatesAutomatically = false
+        geofenceLocationManager = manager
+        return manager
+    }
+
+    private func geofenceAvailable(_ manager: CLLocationManager) -> Bool {
+        CLLocationManager.isMonitoringAvailable(for: CLCircularRegion.self) && manager.authorizationStatus == .authorizedAlways
+    }
+
+    private func persistGeofenceConfiguration() {
+        let defaults = UserDefaults.standard
+        defaults.set(geofenceBackendUrl?.absoluteString, forKey: geofenceUrlKey)
+        defaults.set(geofenceNotifyOnEntry, forKey: geofenceNotifyOnEntryKey)
+        defaults.set(geofenceNotifyOnExit, forKey: geofenceNotifyOnExitKey)
+        if JSONSerialization.isValidJSONObject(geofencePayload),
+           let data = try? JSONSerialization.data(withJSONObject: geofencePayload) {
+            defaults.set(data, forKey: geofencePayloadKey)
+        } else {
+            defaults.removeObject(forKey: geofencePayloadKey)
+        }
+    }
+
+    private func restoreGeofenceConfiguration() {
+        let defaults = UserDefaults.standard
+        if let urlString = defaults.string(forKey: geofenceUrlKey), !urlString.isEmpty {
+            geofenceBackendUrl = URL(string: urlString)
+        }
+        if defaults.object(forKey: geofenceNotifyOnEntryKey) != nil {
+            geofenceNotifyOnEntry = defaults.bool(forKey: geofenceNotifyOnEntryKey)
+        }
+        if defaults.object(forKey: geofenceNotifyOnExitKey) != nil {
+            geofenceNotifyOnExit = defaults.bool(forKey: geofenceNotifyOnExitKey)
+        }
+        if let data = defaults.data(forKey: geofencePayloadKey),
+           let payload = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+            geofencePayload = payload
+        }
+    }
+
+    private func persistGeofenceRegion(_ region: CLCircularRegion, payload: [String: Any]) {
+        let data: [String: Any] = [
+            "latitude": region.center.latitude,
+            "longitude": region.center.longitude,
+            "radius": region.radius,
+            "payload": payload
+        ]
+        if JSONSerialization.isValidJSONObject(data),
+           let encoded = try? JSONSerialization.data(withJSONObject: data) {
+            UserDefaults.standard.set(encoded, forKey: geofenceRegionPrefix + region.identifier)
+        }
+    }
+
+    private func persistedGeofenceRegion(_ identifier: String) -> [String: Any] {
+        guard let data = UserDefaults.standard.data(forKey: geofenceRegionPrefix + identifier),
+              let decoded = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return [:]
+        }
+        return decoded
+    }
+
+    private func removePersistedGeofenceRegion(_ identifier: String) {
+        UserDefaults.standard.removeObject(forKey: geofenceRegionPrefix + identifier)
+    }
+
+    private func persistedGeofenceRegionIds() -> Set<String> {
+        Set(UserDefaults.standard.dictionaryRepresentation().keys.compactMap { key in
+            guard key.hasPrefix(geofenceRegionPrefix) else { return nil }
+            return String(key.dropFirst(geofenceRegionPrefix.count))
+        })
+    }
+
+    private func geofenceTransitionData(for region: CLRegion, enter: Bool) -> [String: Any] {
+        let persistedRegion = persistedGeofenceRegion(region.identifier)
+        let regionPayload = persistedRegion["payload"] as? [String: Any] ?? [:]
+        var payload = geofencePayload
+        for (key, value) in regionPayload {
+            payload[key] = value
+        }
+
+        var data = payload
+        data["identifier"] = region.identifier
+        data["transition"] = enter ? "enter" : "exit"
+        data["enter"] = enter
+        if let circularRegion = region as? CLCircularRegion {
+            data["latitude"] = circularRegion.center.latitude
+            data["longitude"] = circularRegion.center.longitude
+            data["radius"] = circularRegion.radius
+        } else {
+            data["latitude"] = persistedRegion["latitude"]
+            data["longitude"] = persistedRegion["longitude"]
+            data["radius"] = persistedRegion["radius"]
+        }
+        data["payload"] = payload
+        return data
+    }
+
+    private func handleGeofenceTransition(for region: CLRegion, enter: Bool) {
+        if let circularRegion = region as? CLCircularRegion {
+            if enter && !circularRegion.notifyOnEntry {
+                return
+            }
+            if !enter && !circularRegion.notifyOnExit {
+                return
+            }
+        }
+
+        let transition = enter ? "enter" : "exit"
+        if lastGeofenceTransition[region.identifier] == transition {
+            return
+        }
+        lastGeofenceTransition[region.identifier] = transition
+
+        let data = geofenceTransitionData(for: region, enter: enter)
+        notifyListeners("geofenceTransition", data: data, retainUntilConsumed: true)
+        postGeofenceTransition(data)
+    }
+
+    private func postGeofenceTransition(_ data: [String: Any]) {
+        guard let backendUrl = geofenceBackendUrl,
+              JSONSerialization.isValidJSONObject(data),
+              let body = try? JSONSerialization.data(withJSONObject: data) else {
+            return
+        }
+        var request = URLRequest(url: backendUrl)
+        request.httpMethod = "POST"
+        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.addValue("application/json", forHTTPHeaderField: "Accept")
+        request.httpBody = body
+
+        var backgroundTask = UIBackgroundTaskIdentifier.invalid
+        backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "CapgoGeofenceTransition") {
+            if backgroundTask != .invalid {
+                UIApplication.shared.endBackgroundTask(backgroundTask)
+                backgroundTask = .invalid
+            }
+        }
+        URLSession.shared.dataTask(with: request) { _, _, _ in
+            if backgroundTask != .invalid {
+                UIApplication.shared.endBackgroundTask(backgroundTask)
+                backgroundTask = .invalid
+            }
+        }.resume()
+    }
+
     private func startUpdatingLocation() {
         // Avoid unnecessary calls to startUpdatingLocation, which can
         // result in extraneous invocations of didFailWithError.
@@ -353,7 +710,8 @@ public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBri
         _ manager: CLLocationManager,
         didFailWithError error: Error
     ) {
-        guard let callbackId = activeCallbackId,
+        guard manager === locationManager,
+              let callbackId = activeCallbackId,
               let call = self.bridge?.savedCall(withID: callbackId) else {
             return
         }
@@ -378,7 +736,8 @@ public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBri
         _ manager: CLLocationManager,
         didUpdateLocations locations: [CLLocation]
     ) {
-        guard let location = locations.last,
+        guard manager === locationManager,
+              let location = locations.last,
               let callbackId = activeCallbackId,
               let call = self.bridge?.savedCall(withID: callbackId) else {
             return
@@ -394,14 +753,76 @@ public class BackgroundGeolocation: CAPPlugin, CLLocationManagerDelegate, CAPBri
         _ manager: CLLocationManager,
         didChangeAuthorization status: CLAuthorizationStatus
     ) {
+        if let pendingCall = pendingGeofenceSetupCall {
+            if status == .authorizedAlways {
+                pendingGeofenceSetupTimeout?.cancel()
+                pendingGeofenceSetupTimeout = nil
+                pendingGeofenceSetupCall = nil
+                pendingCall.resolve()
+            } else if status == .denied || status == .restricted || status == .authorizedWhenInUse {
+                pendingGeofenceSetupTimeout?.cancel()
+                pendingGeofenceSetupTimeout = nil
+                pendingGeofenceSetupCall = nil
+                pendingCall.reject("Always location permission is required for geofencing", "NOT_AUTHORIZED")
+            }
+        }
+
         // If this method is called before the user decides on a permission, as
         // it is on iOS 14 when the permissions dialog is presented, we ignore
         // it.
-        if status != .notDetermined {
+        if manager === locationManager && status != .notDetermined {
             startUpdatingLocation()
         }
     }
 
+    public func locationManager(_ manager: CLLocationManager, didStartMonitoringFor region: CLRegion) {
+        guard manager === geofenceLocationManager else { return }
+        if let pending = pendingGeofenceRegions.removeValue(forKey: region.identifier) {
+            persistGeofenceRegion(pending.region, payload: pending.payload)
+            pendingGeofenceAddCalls.removeValue(forKey: region.identifier)?.resolve()
+        }
+        manager.requestState(for: region)
+    }
+
+    public func locationManager(_ manager: CLLocationManager, monitoringDidFailFor region: CLRegion?, withError error: Error) {
+        guard manager === geofenceLocationManager, let region = region else { return }
+        pendingGeofenceRegions.removeValue(forKey: region.identifier)
+        removePersistedGeofenceRegion(region.identifier)
+        pendingGeofenceAddCalls.removeValue(forKey: region.identifier)?.reject(
+            "Could not start monitoring the geofence",
+            "MONITORING_FAILED",
+            error
+        )
+        let nsError = error as NSError
+        notifyListeners(
+            "geofenceError",
+            data: [
+                "identifier": region.identifier,
+                "message": error.localizedDescription,
+                "code": nsError.code,
+                "domain": nsError.domain
+            ],
+            retainUntilConsumed: true
+        )
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+        guard manager === geofenceLocationManager, region is CLCircularRegion else { return }
+        handleGeofenceTransition(for: region, enter: true)
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+        guard manager === geofenceLocationManager, region is CLCircularRegion else { return }
+        handleGeofenceTransition(for: region, enter: false)
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didDetermineState state: CLRegionState, for region: CLRegion) {
+        guard manager === geofenceLocationManager, region is CLCircularRegion else { return }
+        if state == .inside {
+            handleGeofenceTransition(for: region, enter: true)
+        }
+    }
+
     @objc func getPluginVersion(_ call: CAPPluginCall) {
         call.resolve(["version": self.pluginVersion])
     }

package/ios/Tests/CapgoBackgroundGeolocationPluginTests/CapgoBackgroundGeolocationPluginTests.swift

@@ -39,6 +39,11 @@ class CapgoBackgroundGeolocationTests: XCTestCase {
         XCTAssertTrue(methodNames.contains("stop"))
         XCTAssertTrue(methodNames.contains("openSettings"))
         XCTAssertTrue(methodNames.contains("setPlannedRoute"))
+        XCTAssertTrue(methodNames.contains("setupGeofencing"))
+        XCTAssertTrue(methodNames.contains("addGeofence"))
+        XCTAssertTrue(methodNames.contains("removeGeofence"))
+        XCTAssertTrue(methodNames.contains("removeAllGeofences"))
+        XCTAssertTrue(methodNames.contains("getMonitoredGeofences"))
         XCTAssertTrue(methodNames.contains("getPluginVersion"))
     }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capgo/background-geolocation",
-  "version": "8.0.32",
-  "description": "Receive accurate geolocation updates even while the app is in the background.",
+  "version": "8.0.34",
+  "description": "Accurate background geolocation and native geofencing for Capacitor apps on iOS and Android.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
@@ -26,23 +26,23 @@
   },
   "homepage": "https://capgo.app/docs/plugins/background-geolocation/",
   "scripts": {
-    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify": "bun run verify:ios && bun run verify:android && bun run verify:web",
     "verify:ios": "xcodebuild -scheme CapgoBackgroundGeolocation -destination generic/platform=iOS",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
-    "verify:web": "npm run build",
-    "test": "npm run test:ios && npm run test:android",
+    "verify:web": "bun run build",
+    "test": "bun run test:ios && bun run test:android",
     "test:ios": "./scripts/test-ios.sh",
     "test:android": "cd android && ./gradlew test && cd ..",
-    "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",
+    "lint": "bun run eslint && bun run prettier -- --check && bun run swiftlint -- lint",
+    "fmt": "bun run eslint -- --fix && bun run prettier -- --write && bun run swiftlint -- --fix --format",
     "eslint": "eslint . --ext ts",
     "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
     "swiftlint": "node-swiftlint",
     "docgen": "docgen --api BackgroundGeolocationPlugin --output-readme README.md --output-json dist/docs.json",
-    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "build": "bun run clean && bun run docgen && tsc && rollup -c rollup.config.mjs",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "bun run build"
   },
   "keywords": [
     "capacitor",
@@ -50,7 +50,14 @@
     "native",
     "accurate",
     "background",
-    "geolocation"
+    "geolocation",
+    "geofence",
+    "geofencing",
+    "location",
+    "background-location",
+    "ios-geofencing",
+    "android-geofencing",
+    "webhook"
   ],
   "devDependencies": {
     "@capacitor/android": "^8.0.0",