@bglocation/capacitor 1.1.0

package/android/src/main/kotlin/dev/bglocation/BackgroundLocationPlugin.kt

@@ -0,0 +1,684 @@
+package dev.bglocation
+
+import android.Manifest
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.pm.PackageManager
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.util.Log
+import androidx.core.app.ActivityCompat
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import dev.bglocation.core.*
+import dev.bglocation.core.battery.BGLBatteryHelper
+import dev.bglocation.core.battery.BGLBatteryState
+import dev.bglocation.core.config.BGLConfigParser
+import dev.bglocation.core.config.BGLVersion
+import dev.bglocation.core.debug.BGLDebugLogger
+import dev.bglocation.core.geofence.BGLGeofenceBroadcastReceiver
+import dev.bglocation.core.geofence.BGLGeofenceConfig
+import dev.bglocation.core.geofence.BGLGeofenceManager
+import dev.bglocation.core.http.BGLHttpResult
+import dev.bglocation.core.license.BGLBuildConfig
+import dev.bglocation.core.license.BGLLicenseEnforcer
+import dev.bglocation.core.license.BGLLicenseValidator
+import dev.bglocation.core.license.BGLTrialTimer
+import dev.bglocation.core.location.BGLLocationForegroundService
+import dev.bglocation.core.location.BGLLocationHelpers
+import dev.bglocation.core.location.BGLPermissionManager
+import org.json.JSONObject
+
+@CapacitorPlugin(
+    name = "BackgroundLocation",
+    permissions = [
+        Permission(
+            strings = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION],
+            alias = "location"
+        ),
+        Permission(
+            strings = ["android.permission.ACCESS_BACKGROUND_LOCATION"],
+            alias = "backgroundLocation"
+        )
+    ]
+)
+class BackgroundLocationPlugin : Plugin() {
+
+    companion object {
+        private const val TAG = "BGLocation"
+        private const val LICENSE_PREFS_NAME = "bglocation_license"
+        private const val SERVICE_BIND_TIMEOUT_MS = 10_000L
+    }
+
+    private val permissionManager = BGLPermissionManager()
+
+    @PluginMethod
+    fun getVersion(call: PluginCall) {
+        val result = JSObject()
+        result.put("pluginVersion", "1.1.0")
+        result.put("coreVersion", BGLVersion.VERSION)
+        call.resolve(result)
+    }
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        val capState = getPermissionState("location")
+        val capStateStr = if (capState != null && capState.toString() == "denied") "denied" else null
+        val result = permissionManager.buildPermissionStatus(context, activity, capStateStr)
+        call.resolve(result.toJSObject())
+    }
+
+    // C.2: Override requestPermissions to emit onPermissionRationale before
+    // requesting background location on Android 11+ (API 30+).
+    // On Android 11+, the system dialog does NOT show "Allow all the time" —
+    // the user must navigate to Settings manually. We emit an event so the
+    // JS layer can display a custom rationale UI before triggering the request.
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        val permissions = call.getArray("permissions")?.toList<String>() ?: listOf("location")
+
+        val rationale = permissionManager.buildBackgroundRationale(context, activity, permissions)
+        if (rationale != null) {
+            notifyListeners("onPermissionRationale", rationale.toJSObject())
+        }
+
+        // Delegate to Capacitor's built-in permission handling
+        super.requestPermissions(call)
+    }
+
+    private var locationService: BGLLocationForegroundService? = null
+    private var isBound = false
+    private var pendingStartCall: PluginCall? = null
+    private val startTimeoutHandler = Handler(Looper.getMainLooper())
+
+    // Configuration stored until service starts
+    internal var config = BGLLocationConfig()
+    internal lateinit var batteryHelper: BGLBatteryHelper
+
+    // Licensing
+    internal lateinit var licenseEnforcer: BGLLicenseEnforcer
+    // Keep direct accessors for backward-compatible test access
+    internal val licenseMode: BGLLicenseMode get() = licenseEnforcer.licenseMode
+    internal val trialTimer: BGLTrialTimer? get() = licenseEnforcer.trialTimer
+
+    // Geofencing
+    private var geofenceManager: BGLGeofenceManager? = null
+    private var isConfigured = false
+
+    // Debug logger for geofence operations (lives in bridge, not service)
+    private val geofenceDebug = BGLDebugLogger()
+
+    override fun load() {
+        BGLBuildConfig.buildEpoch = BuildConfig.PLUGIN_BUILD_EPOCH
+        batteryHelper = BGLBatteryHelper(context)
+
+        val licensePrefs = context.getSharedPreferences(LICENSE_PREFS_NAME, Context.MODE_PRIVATE)
+        val licenseValidator = BGLLicenseValidator(licensePrefs)
+        licenseEnforcer = BGLLicenseEnforcer(licensePrefs, licenseValidator)
+    }
+
+    private val serviceConnection = object : ServiceConnection {
+        override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
+            startTimeoutHandler.removeCallbacksAndMessages(null)
+
+            val localBinder = binder as BGLLocationForegroundService.LocalBinder
+            locationService = localBinder.getService()
+            isBound = true
+
+            locationService?.configure(config)
+
+            // IMPORTANT: Set callbacks BEFORE startTracking() to prevent
+            // race conditions where events fire before handlers are registered.
+            locationService?.onLocation = { location ->
+                emitLocation(location)
+            }
+            locationService?.onProviderChange = { enabled ->
+                emitProviderChange(enabled)
+            }
+            locationService?.onHeartbeat = { location ->
+                emitHeartbeat(location)
+            }
+            locationService?.onHttp = { result ->
+                emitHttp(result)
+            }
+            locationService?.debug?.onDebug = { message ->
+                emitDebug(message)
+            }
+            locationService?.onMockLocation = { location ->
+                emitMockLocation(location)
+            }
+
+            locationService?.startTracking()
+
+            // Start trial timer if in trial mode
+            licenseEnforcer.startTrialIfNeeded()
+
+            // Emit battery warning if optimization is active (B.1)
+            checkAndEmitBatteryWarning()
+
+            pendingStartCall?.let { call ->
+                val result = JSObject().apply {
+                    put("enabled", true)
+                    put("tracking", true)
+                }
+                call.resolve(result)
+                pendingStartCall = null
+            }
+
+            Log.d(TAG, "BackgroundLocation service connected")
+        }
+
+        override fun onServiceDisconnected(name: ComponentName?) {
+            locationService = null
+            isBound = false
+            Log.d(TAG, "BackgroundLocation service disconnected")
+        }
+    }
+
+    @PluginMethod
+    fun configure(call: PluginCall) {
+        config = BGLConfigParser.parseLocationConfig(call.data)
+
+        // --- License validation ---
+        val licenseKey = getConfig().getString("licenseKey")
+        val bundleId = context.packageName
+        val configureResult = JSObject()
+
+        config = licenseEnforcer.validateLicense(licenseKey, bundleId, config, configureResult) {
+            onTrialExpired()
+        }
+
+        // If service is already running, update config
+        locationService?.configure(config)
+
+        // --- Geofencing setup ---
+        val manager = BGLGeofenceManager(context)
+        manager.onGeofenceEvent = { event ->
+            notifyListeners("onGeofence", event.toJSONObject().toJSObject())
+            Log.d(TAG, "Geofence ${event.action}: ${event.identifier}")
+        }
+        geofenceManager = manager
+        BGLGeofenceBroadcastReceiver.geofenceManager = manager
+
+        // Configure debug logger for geofence operations
+        geofenceDebug.configure(config.debug, config.debugSounds)
+        geofenceDebug.onDebug = { message -> emitDebug(message) }
+        BGLGeofenceBroadcastReceiver.debugLogger = geofenceDebug
+
+        // Re-register persisted geofences (they survive app restarts but not reboots)
+        manager.reRegisterAllGeofences()
+
+        isConfigured = true
+
+        Log.d(TAG, "BackgroundLocation configured — distanceFilter=${config.distanceFilter} (mode=${config.distanceFilterMode}), heartbeat=${config.heartbeatInterval}s, http=${config.http?.url ?: "disabled"}")
+        configureResult.put("distanceFilterMode", config.distanceFilterMode)
+        call.resolve(configureResult)
+    }
+
+    @PluginMethod
+    fun start(call: PluginCall) {
+        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION)
+            != PackageManager.PERMISSION_GRANTED
+        ) {
+            call.reject("Location permission not granted")
+            return
+        }
+
+        // Trial mode: check cooldown before allowing start
+        val cooldown = licenseEnforcer.checkCooldown()
+        if (cooldown != null) {
+            call.reject(
+                cooldown.message,
+                "TRIAL_COOLDOWN",
+                Exception("Trial cooldown active"),
+                JSObject().apply {
+                    put("remainingSeconds", cooldown.remainingSeconds)
+                    put("message", cooldown.message)
+                }
+            )
+            return
+        }
+
+        // Reject any previous unresolved start() call
+        pendingStartCall?.reject("Superseded by a new start() call")
+        pendingStartCall = call
+
+        // Add timeout for service binding — reject if onServiceConnected not called within 10s
+        startTimeoutHandler.removeCallbacksAndMessages(null)
+        startTimeoutHandler.postDelayed({
+            pendingStartCall?.reject("Service connection timed out")
+            pendingStartCall = null
+        }, SERVICE_BIND_TIMEOUT_MS)
+
+        val intent = Intent(context, BGLLocationForegroundService::class.java)
+        context.startForegroundService(intent)
+        context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
+
+        Log.d(TAG, "BackgroundLocation starting service")
+    }
+
+    /**
+     * Internal stop — tears down service, unbinds, and clears references.
+     * Shared by stop() and onTrialExpired() to avoid duplicating cleanup logic.
+     */
+    private fun performStopTracking() {
+        locationService?.stopTracking()
+        if (isBound) {
+            context.unbindService(serviceConnection)
+            isBound = false
+        }
+        val intent = Intent(context, BGLLocationForegroundService::class.java)
+        context.stopService(intent)
+        locationService = null
+    }
+
+    @PluginMethod
+    fun stop(call: PluginCall) {
+        // Only stop the trial timer if no geofences are active
+        licenseEnforcer.stopTrialIfNoGeofences(geofenceManager?.hasGeofences == true)
+        performStopTracking()
+
+        val hasPermission = ActivityCompat.checkSelfPermission(
+            context, Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+
+        Log.d(TAG, "BackgroundLocation stopped")
+        val result = JSObject().apply {
+            put("enabled", hasPermission)
+            put("tracking", false)
+        }
+        call.resolve(result)
+    }
+
+    @PluginMethod
+    fun getState(call: PluginCall) {
+        val isTracking = locationService?.isTracking ?: false
+        val hasPermission = activity?.let {
+            ActivityCompat.checkSelfPermission(it, Manifest.permission.ACCESS_FINE_LOCATION) ==
+                PackageManager.PERMISSION_GRANTED
+        } ?: false
+        val result = JSObject().apply {
+            put("enabled", hasPermission)
+            put("tracking", isTracking)
+        }
+        call.resolve(result)
+    }
+
+    @PluginMethod
+    fun getCurrentPosition(call: PluginCall) {
+        val service = locationService
+        if (service == null) {
+            call.reject("Service not running")
+            return
+        }
+
+        service.getCurrentPosition { location ->
+            if (location != null) {
+                call.resolve(BGLLocationHelpers.toJSONObject(location).toJSObject())
+            } else {
+                call.reject("Unable to get current position — no location available")
+            }
+        }
+    }
+
+    // MARK: - Geofencing Methods
+
+    @PluginMethod
+    fun addGeofence(call: PluginCall) {
+        val manager = geofenceManager
+        if (!isConfigured || manager == null) {
+            call.reject("Plugin not configured. Call configure() first.", "NOT_CONFIGURED")
+            return
+        }
+
+        val cooldown = licenseEnforcer.checkCooldown()
+        if (cooldown != null) {
+            call.reject(
+                cooldown.message,
+                "TRIAL_COOLDOWN",
+                Exception("Trial cooldown active"),
+                JSObject().apply { put("remainingSeconds", cooldown.remainingSeconds) }
+            )
+            return
+        }
+
+        val identifier = call.getString("identifier")
+        if (identifier == null) {
+            call.reject("Missing required parameter: identifier")
+            return
+        }
+        val latitude = call.getDouble("latitude")
+        val longitude = call.getDouble("longitude")
+        val radius = call.getDouble("radius")
+
+        if (latitude == null || longitude == null || radius == null) {
+            call.reject("Missing required parameters: latitude, longitude, radius")
+            return
+        }
+
+        val extras = call.getObject("extras", null)?.let { extrasObj ->
+            extrasObj.keys().asSequence().associateWith { key -> extrasObj.optString(key, "") }
+        }
+
+        val geofence = BGLGeofenceConfig(
+            identifier = identifier,
+            latitude = latitude,
+            longitude = longitude,
+            radius = radius,
+            notifyOnEntry = call.getBoolean("notifyOnEntry", true) ?: true,
+            notifyOnExit = call.getBoolean("notifyOnExit", true) ?: true,
+            notifyOnDwell = call.getBoolean("notifyOnDwell", false) ?: false,
+            dwellDelay = call.getInt("dwellDelay", 300) ?: 300,
+            extras = extras
+        )
+
+        manager.addGeofence(geofence,
+            onSuccess = {
+                licenseEnforcer.startTrialIfNeeded()
+                geofenceDebug.logGeofenceAdd(identifier)
+                Log.d(TAG, "Geofence added: $identifier")
+                call.resolve()
+            },
+            onError = { errorMsg ->
+                val code = if (errorMsg.contains("limit")) "GEOFENCE_LIMIT_EXCEEDED" else "GEOFENCE_ERROR"
+                call.reject(errorMsg, code)
+            }
+        )
+    }
+
+    @PluginMethod
+    fun addGeofences(call: PluginCall) {
+        val manager = geofenceManager
+        if (!isConfigured || manager == null) {
+            call.reject("Plugin not configured. Call configure() first.", "NOT_CONFIGURED")
+            return
+        }
+
+        val cooldown = licenseEnforcer.checkCooldown()
+        if (cooldown != null) {
+            call.reject(
+                cooldown.message,
+                "TRIAL_COOLDOWN",
+                Exception("Trial cooldown active"),
+                JSObject().apply { put("remainingSeconds", cooldown.remainingSeconds) }
+            )
+            return
+        }
+
+        val geofencesArray = call.getArray("geofences")
+        if (geofencesArray == null) {
+            call.reject("Missing required parameter: geofences")
+            return
+        }
+
+        val geofences = mutableListOf<BGLGeofenceConfig>()
+        for (i in 0 until geofencesArray.length()) {
+            val obj = geofencesArray.optJSONObject(i)
+            if (obj == null) {
+                call.reject("Geofence at index $i is not a valid object")
+                return
+            }
+            val identifier = if (obj.has("identifier")) obj.getString("identifier") else null
+            val lat = if (obj.has("latitude")) obj.getDouble("latitude") else null
+            val lng = if (obj.has("longitude")) obj.getDouble("longitude") else null
+            val rad = if (obj.has("radius")) obj.getDouble("radius") else null
+
+            if (identifier == null || lat == null || lng == null || rad == null) {
+                call.reject("Geofence at index $i missing required fields (identifier, latitude, longitude, radius)")
+                return
+            }
+
+            val extras = obj.optJSONObject("extras")?.let { extrasObj ->
+                extrasObj.keys().asSequence().associateWith { key -> extrasObj.optString(key, "") }
+            }
+
+            geofences.add(BGLGeofenceConfig(
+                identifier = identifier,
+                latitude = lat,
+                longitude = lng,
+                radius = rad,
+                notifyOnEntry = obj.optBoolean("notifyOnEntry", true),
+                notifyOnExit = obj.optBoolean("notifyOnExit", true),
+                notifyOnDwell = obj.optBoolean("notifyOnDwell", false),
+                dwellDelay = obj.optInt("dwellDelay", 300),
+                extras = extras
+            ))
+        }
+
+        manager.addGeofences(geofences,
+            onSuccess = {
+                licenseEnforcer.startTrialIfNeeded()
+                geofenceDebug.logGeofenceAddBatch(geofences.size)
+                Log.d(TAG, "Batch added ${geofences.size} geofences")
+                call.resolve()
+            },
+            onError = { errorMsg ->
+                val code = if (errorMsg.contains("limit")) "GEOFENCE_LIMIT_EXCEEDED" else "GEOFENCE_ERROR"
+                call.reject(errorMsg, code)
+            }
+        )
+    }
+
+    @PluginMethod
+    fun removeGeofence(call: PluginCall) {
+        val manager = geofenceManager
+        if (!isConfigured || manager == null) {
+            call.reject("Plugin not configured. Call configure() first.", "NOT_CONFIGURED")
+            return
+        }
+
+        val identifier = call.getString("identifier")
+        if (identifier == null) {
+            call.reject("Missing required parameter: identifier")
+            return
+        }
+
+        manager.removeGeofence(identifier)
+        geofenceDebug.logGeofenceRemove(identifier)
+
+        // If no geofences and no tracking, stop trial timer
+        val isTracking = locationService?.isTracking ?: false
+        licenseEnforcer.stopTrialIfIdle(!manager.hasGeofences, isTracking)
+
+        Log.d(TAG, "Geofence removed: $identifier")
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun removeAllGeofences(call: PluginCall) {
+        val manager = geofenceManager
+        if (!isConfigured || manager == null) {
+            call.reject("Plugin not configured. Call configure() first.", "NOT_CONFIGURED")
+            return
+        }
+
+        val count = manager.getGeofences().size
+        manager.removeAllGeofences()
+        geofenceDebug.logGeofenceRemoveAll(count)
+
+        // If not tracking, stop trial timer
+        val isTracking = locationService?.isTracking ?: false
+        licenseEnforcer.stopTrialIfIdle(hasGeofences = false, isTracking = isTracking)
+
+        Log.d(TAG, "All geofences removed")
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun getGeofences(call: PluginCall) {
+        val manager = geofenceManager
+        if (!isConfigured || manager == null) {
+            call.reject("Plugin not configured. Call configure() first.", "NOT_CONFIGURED")
+            return
+        }
+
+        val geofences = manager.getGeofences()
+        val result = com.getcapacitor.JSArray()
+        for (geofence in geofences) {
+            val obj = JSObject().apply {
+                put("identifier", geofence.identifier)
+                put("latitude", geofence.latitude)
+                put("longitude", geofence.longitude)
+                put("radius", geofence.radius)
+                put("notifyOnEntry", geofence.notifyOnEntry)
+                put("notifyOnExit", geofence.notifyOnExit)
+                put("notifyOnDwell", geofence.notifyOnDwell)
+                put("dwellDelay", geofence.dwellDelay)
+                geofence.extras?.let { extras ->
+                    put("extras", org.json.JSONObject(extras))
+                }
+            }
+            result.put(obj)
+        }
+
+        val response = JSObject().apply {
+            put("geofences", result)
+        }
+        call.resolve(response)
+    }
+
+    // MARK: - Battery Optimization (B.1)
+
+    @PluginMethod
+    fun checkBatteryOptimization(call: PluginCall) {
+        call.resolve(batteryStateToJSObject(batteryHelper.checkState()))
+    }
+
+    @PluginMethod
+    fun requestBatteryOptimization(call: PluginCall) {
+        val intent = batteryHelper.createBatteryOptimizationIntent()
+        if (intent != null) {
+            try {
+                context.startActivity(intent)
+            } catch (e: Exception) {
+                Log.w(TAG, "Failed to open battery optimization settings: ${e.message}")
+            }
+        }
+        // Return state before user interaction — caller should re-check
+        // with checkBatteryOptimization() after app resumes.
+        call.resolve(batteryStateToJSObject(batteryHelper.checkState()))
+    }
+
+    /**
+     * Emit onBatteryWarning if battery optimization is active.
+     * Called automatically on start() to warn about potential tracking issues.
+     */
+    private fun checkAndEmitBatteryWarning() {
+        val state = batteryHelper.checkState()
+        if (!state.isIgnoringOptimizations) {
+            notifyListeners("onBatteryWarning", batteryStateToJSObject(state))
+            Log.w(TAG, "Battery optimization active — ${state.message}")
+        }
+    }
+
+    internal fun batteryStateToJSObject(state: BGLBatteryState): JSObject {
+        return JSObject().apply {
+            put("isIgnoringOptimizations", state.isIgnoringOptimizations)
+            put("manufacturer", state.manufacturer)
+            put("helpUrl", state.helpUrl)
+            put("message", state.message)
+        }
+    }
+
+    // MARK: - Event emission
+
+    private fun emitLocation(location: BGLLocationData) {
+        val jsObj = BGLLocationHelpers.toJSONObject(location).toJSObject()
+        // Add effectiveDistanceFilter in auto mode
+        if (config.distanceFilterMode == "auto") {
+            val effective = locationService?.adaptiveFilter?.effectiveDistanceFilter
+            if (effective != null) {
+                jsObj.put("effectiveDistanceFilter", effective.toDouble())
+            }
+        }
+        notifyListeners("onLocation", jsObj)
+    }
+
+    private fun emitHeartbeat(location: BGLLocationData?) {
+        val data = JSObject().apply {
+            if (location != null) {
+                put("location", BGLLocationHelpers.toJSONObject(location))
+            } else {
+                put("location", org.json.JSONObject.NULL)
+            }
+            put("timestamp", System.currentTimeMillis())
+        }
+        notifyListeners("onHeartbeat", data)
+    }
+
+    private fun emitProviderChange(enabled: Boolean) {
+        val data = JSObject().apply {
+            put("gps", enabled)
+            put("network", enabled)
+            put("enabled", enabled)
+            put("status", if (enabled) 1 else 0)
+        }
+        notifyListeners("onProviderChange", data)
+    }
+
+    private fun emitHttp(result: BGLHttpResult) {
+        val data = JSObject().apply {
+            put("statusCode", result.statusCode)
+            put("success", result.success)
+            put("responseText", result.responseText)
+            if (result.error != null) {
+                put("error", result.error)
+            }
+            put("bufferedCount", result.bufferedCount)
+        }
+        notifyListeners("onHttp", data)
+    }
+
+    private fun emitMockLocation(location: BGLLocationData) {
+        val data = JSObject().apply {
+            put("location", BGLLocationHelpers.toJSONObject(location))
+            put("message", "Mock location detected — the device is using a mock/test location provider.")
+        }
+        notifyListeners("onMockLocation", data)
+        Log.w(TAG, "Mock location detected — (${location.latitude}, ${location.longitude})")
+    }
+
+    private fun emitDebug(message: String) {
+        val data = JSObject().apply {
+            put("message", message)
+            put("timestamp", System.currentTimeMillis())
+        }
+        notifyListeners("onDebug", data)
+    }
+
+    /**
+     * Called by BGLTrialTimer when the 30-minute trial period expires.
+     * Auto-stops tracking and emits onTrialExpired event.
+     */
+    private fun onTrialExpired() {
+        performStopTracking()
+        geofenceManager?.removeAllGeofences()
+
+        val cooldownMinutes = BGLTrialTimer.COOLDOWN_DURATION_SECONDS / 60
+        val data = JSObject().apply {
+            put("elapsed", BGLTrialTimer.TRIAL_DURATION_SECONDS)
+            put("cooldownSeconds", BGLTrialTimer.COOLDOWN_DURATION_SECONDS)
+            put("message", "Trial expired. Next start available in $cooldownMinutes minutes. Purchase a license for unlimited use.")
+        }
+        notifyListeners("onTrialExpired", data)
+        Log.w(TAG, "Trial expired — tracking auto-stopped, cooldown started (${BGLTrialTimer.COOLDOWN_DURATION_SECONDS}s)")
+    }
+
+    override fun handleOnDestroy() {
+        if (isBound) {
+            context.unbindService(serviceConnection)
+            isBound = false
+        }
+        super.handleOnDestroy()
+    }
+}
+
+/** Convert core JSONObject to Capacitor JSObject */
+private fun JSONObject.toJSObject(): JSObject = JSObject(this.toString())