akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/geolocation/android/GeolocationPlugin.kt

@@ -0,0 +1,360 @@
+package com.akanjs.plugins.geolocation
+
+import android.Manifest
+import android.app.Activity
+import android.app.Application
+import android.content.pm.PackageManager
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.location.LocationRequest
+import android.os.Build
+import android.os.Bundle
+import android.os.CancellationSignal
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import android.util.Log
+import java.util.concurrent.Executor
+import java.util.function.Consumer
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+
+/**
+ * Framework LocationManager instead of Play Services FusedLocationProviderClient (plugins.md §2),
+ * following tauri-plugins-workspace/plugins/geolocation/android/src/main/java/Geolocation.kt:
+ * - Provider: LocationManager.FUSED_PROVIDER (API 31; implemented by Play services where present,
+ *   by the AOSP FusedLocation otherwise), else GPS for high accuracy with fine permission, else
+ *   NETWORK. GPS is never used with coarse permission only.
+ * - Both ACCESS_FINE_LOCATION and ACCESS_COARSE_LOCATION are requested together: on Android 12+
+ *   the dialog offers precise or approximate, and the user may grant coarse only (precise: false,
+ *   the system then coarsens every fix; a high-accuracy request quietly gets the approximate one).
+ *   Balanced and coarse-only requests do not turn on GPS: where there is no network location
+ *   (the emulator, verified) they only get a fix another request produced recently, or time out.
+ *   capacitor/android/.../BridgeWebChromeClient.java:246-273 treats coarse as enough in the same way.
+ * - getCurrentPosition: newest getLastKnownLocation within maximumAge (Tauri's getLastLocation),
+ *   else getCurrentLocation (API 31 LocationRequest overload) with a CancellationSignal for the
+ *   timeout. The platform ends a single request after at most 30 s with null (NOT_FOUND).
+ * - Watches stop on pause and resume on resume (Tauri onPause/onResume): background delivery would
+ *   need ACCESS_BACKGROUND_LOCATION or a foreground service.
+ * - Location turned off is NOT_FOUND for getCurrentPosition and an "error" event for a watch, whose
+ *   registration stays so updates resume when it is turned on (Tauri rejects checkPermissions instead).
+ * Emulator: `adb emu geo fix <lon> <lat>`, `adb shell pm grant <app id> android.permission.ACCESS_FINE_LOCATION`.
+ * Arguments arrive decoded and checked by the generated GeolocationPluginSpec (PL-10); the ranges
+ * of timeout and maximumAge are checked here.
+ */
+class GeolocationPlugin(private val context: AkanNativePluginContext) : GeolocationPluginSpec {
+    private class Watch(val provider: String, val high: Boolean, val listener: LocationListener)
+
+    private val activity = context.activity
+    private val events = GeolocationEvents(context)
+    private val manager: LocationManager? = activity.getSystemService(LocationManager::class.java)
+    private val main = Handler(Looper.getMainLooper())
+    private val listening = LinkedHashSet<String>()
+    private var watch: Watch? = null
+    private var resumed = true
+    private var askedForWatch = false
+    private var lastReport: String? = null
+
+    private val lifecycle = object : Application.ActivityLifecycleCallbacks {
+        override fun onActivityResumed(activity: Activity) {
+            resumed = true
+            updateWatch() // also picks up a permission granted in Settings meanwhile
+        }
+
+        override fun onActivityPaused(activity: Activity) {
+            resumed = false
+            updateWatch()
+        }
+
+        override fun onActivityStarted(activity: Activity) {}
+        override fun onActivityStopped(activity: Activity) {}
+        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+        override fun onActivityDestroyed(activity: Activity) {}
+    }
+
+    override fun checkPermission(reply: AkanNativeReply<GeolocationLocationPermission>) = reply.resolve(permission())
+
+    override fun requestPermission(reply: AkanNativeReply<GeolocationLocationPermission>) =
+        context.requestPermissions(PERMISSIONS) { reply.resolve(permission()) }
+
+    override fun startListening(event: String) {
+        if (event !in EVENTS) return
+        if (listening.isEmpty()) {
+            askedForWatch = false
+            lastReport = null
+            activity.registerActivityLifecycleCallbacks(lifecycle)
+        }
+        listening.add(event)
+        updateWatch()
+    }
+
+    override fun stopListening(event: String) {
+        if (!listening.remove(event)) return
+        if (listening.isEmpty()) activity.unregisterActivityLifecycleCallbacks(lifecycle)
+        updateWatch()
+    }
+
+    override fun destroy() {
+        if (listening.isNotEmpty()) activity.unregisterActivityLifecycleCallbacks(lifecycle)
+        listening.clear()
+        stopWatch()
+    }
+
+    // ------------------------------------------------------------ permission
+
+    private fun granted(permission: String) = activity.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED
+    private fun fine() = granted(Manifest.permission.ACCESS_FINE_LOCATION)
+    private fun anyLocation() = fine() || granted(Manifest.permission.ACCESS_COARSE_LOCATION)
+
+    private fun permission(): GeolocationLocationPermission =
+        if (anyLocation()) GeolocationLocationPermission(location = GeolocationPermissionState.GRANTED, precise = fine())
+        // Both are always requested together, so the coarse history stands for the pair.
+        else GeolocationLocationPermission(location = permissionState(Manifest.permission.ACCESS_COARSE_LOCATION), precise = null)
+
+    /** context.permissionState answers with one of the four AkanNativePermission strings. */
+    private fun permissionState(permission: String): GeolocationPermissionState {
+        val state = context.permissionState(permission)
+        return GeolocationPermissionState.entries.first { it.json == state }
+    }
+
+    // ------------------------------------------------------------ getCurrentPosition
+
+    /** A non-negative number of ms, or [fallback] when absent. JSON has no Infinity: it arrives as null. */
+    private fun milliseconds(value: Double?, name: String, fallback: Long, reply: AkanNativeReply<*>): Long? {
+        if (value == null) return fallback
+        if (value < 0) {
+            reply.reject(AkanNativeErrorCode.INVALID_ARGS, "$name must be a number of ms >= 0")
+            return null
+        }
+        return value.coerceAtMost(Long.MAX_VALUE.toDouble()).toLong()
+    }
+
+    override fun getCurrentPosition(args: GeolocationPositionOptions, reply: AkanNativeReply<GeolocationPosition>) {
+        val timeout = milliseconds(args.timeout, "timeout", 30_000, reply) ?: return
+        val maximumAge = milliseconds(args.maximumAge, "maximumAge", 0, reply) ?: return
+        val high = args.enableHighAccuracy == true
+        if (anyLocation()) return locate(reply, high, timeout, maximumAge)
+        // Like W3C getCurrentPosition, ask first. After "don't ask again" this answers at once.
+        context.requestPermissions(PERMISSIONS) {
+            if (anyLocation()) locate(reply, high, timeout, maximumAge)
+            else reply.reject(AkanNativeErrorCode.PERMISSION_DENIED, "location access was denied")
+        }
+    }
+
+    private fun locate(reply: AkanNativeReply<GeolocationPosition>, high: Boolean, timeout: Long, maximumAge: Long) {
+        val lm = manager ?: return reply.reject(AkanNativeErrorCode.UNSUPPORTED, "no location service")
+        if (!lm.isLocationEnabled) return reply.reject(AkanNativeErrorCode.NOT_FOUND, "location is turned off")
+        val fine = fine()
+        if (maximumAge > 0) cached(lm, maximumAge)?.let { return reply.resolve(position(it)) }
+        if (timeout == 0L) return reply.reject(AkanNativeErrorCode.NOT_FOUND, "no position within 0 ms")
+        val provider = provider(lm, high, fine, enabledOnly = true)
+            ?: return reply.reject(AkanNativeErrorCode.NOT_FOUND, "no location provider is enabled")
+        val signal = CancellationSignal()
+        var done = false
+        val timer = Runnable {
+            if (!done) {
+                done = true
+                signal.cancel()
+                reply.reject(AkanNativeErrorCode.NOT_FOUND, "no position within $timeout ms")
+            }
+        }
+        main.postDelayed(timer, timeout)
+        val settle = { settleReply: AkanNativeReply<GeolocationPosition>.() -> Unit ->
+            if (!done) {
+                done = true
+                main.removeCallbacks(timer)
+                reply.settleReply()
+            }
+        }
+        val deliver: (Location?) -> Unit = { location ->
+            settle { if (location == null) reject(AkanNativeErrorCode.NOT_FOUND, "no position from $provider") else resolve(position(location)) }
+        }
+        try {
+            when {
+                Build.VERSION.SDK_INT >= 31 -> Api31.currentLocation(lm, provider, high && fine, timeout, signal, activity.mainExecutor, deliver)
+                Build.VERSION.SDK_INT >= 30 -> Api30.currentLocation(lm, provider, signal, activity.mainExecutor, deliver)
+                else -> oneShot(lm, provider, signal, deliver)
+            }
+        } catch (e: SecurityException) { // permission revoked in between
+            settle { reject(AkanNativeErrorCode.PERMISSION_DENIED, e.message ?: "location access was denied") }
+        } catch (e: IllegalArgumentException) { // provider vanished
+            settle { reject(AkanNativeErrorCode.NOT_FOUND, e.message ?: "no provider $provider") }
+        }
+    }
+
+    /**
+     * API 29 has no getCurrentLocation: updates from the provider, removed after the first fix or when
+     * the provider is turned off (androidx LocationManagerCompat). The caller's timer still applies.
+     */
+    private fun oneShot(lm: LocationManager, provider: String, signal: CancellationSignal, done: (Location?) -> Unit) {
+        var finished = false
+        lateinit var listener: LocationListener
+        val finish = { location: Location? ->
+            if (!finished) {
+                finished = true
+                lm.removeUpdates(listener)
+                done(location)
+            }
+        }
+        listener = object : LocationListener {
+            override fun onLocationChanged(location: Location) = finish(location)
+            override fun onProviderDisabled(provider: String) = finish(null)
+            override fun onProviderEnabled(provider: String) {}
+            @Deprecated("abstract before API 30, never called from 29 on")
+            override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
+        }
+        signal.setOnCancelListener {
+            if (!finished) {
+                finished = true
+                lm.removeUpdates(listener)
+            }
+        }
+        lm.requestLocationUpdates(provider, 0L, 0f, listener, Looper.getMainLooper())
+    }
+
+    /** Whether the provider exists. hasProvider is API 31; before it the fused provider is hidden. */
+    private fun has(lm: LocationManager, provider: String): Boolean = when {
+        Build.VERSION.SDK_INT >= 31 -> Api31.hasProvider(lm, provider)
+        provider == LocationManager.FUSED_PROVIDER -> false
+        else -> provider in lm.allProviders
+    }
+
+    /** The newest last known fix of any provider, if it is at most [maximumAge] ms old. */
+    private fun cached(lm: LocationManager, maximumAge: Long): Location? {
+        val now = SystemClock.elapsedRealtimeNanos()
+        return PROVIDERS.asSequence()
+            .filter { has(lm, it) }
+            .mapNotNull { runCatching { lm.getLastKnownLocation(it) }.getOrNull() }
+            .filter { (now - it.elapsedRealtimeNanos) / 1_000_000 <= maximumAge }
+            .maxByOrNull { it.elapsedRealtimeNanos }
+    }
+
+    private fun provider(lm: LocationManager, high: Boolean, fine: Boolean, enabledOnly: Boolean): String? {
+        fun usable(p: String) = has(lm, p) && (!enabledOnly || lm.isProviderEnabled(p))
+        return when {
+            usable(LocationManager.FUSED_PROVIDER) -> LocationManager.FUSED_PROVIDER
+            high && fine && usable(LocationManager.GPS_PROVIDER) -> LocationManager.GPS_PROVIDER
+            usable(LocationManager.NETWORK_PROVIDER) -> LocationManager.NETWORK_PROVIDER
+            fine && usable(LocationManager.GPS_PROVIDER) -> LocationManager.GPS_PROVIDER
+            else -> null
+        }
+    }
+
+    // ------------------------------------------------------------ watch
+
+    private fun updateWatch() {
+        if (listening.isEmpty() || !resumed) return stopWatch()
+        val lm = manager ?: return report(GeolocationErrorCode.UNSUPPORTED, "no location service")
+        if (!anyLocation()) {
+            stopWatch()
+            if (askedForWatch) return report(GeolocationErrorCode.PERMISSION_DENIED, "location access was denied")
+            askedForWatch = true
+            // The dialog pauses the activity; the watch starts on the following resume.
+            context.requestPermissions(PERMISSIONS) { if (!anyLocation()) report(GeolocationErrorCode.PERMISSION_DENIED, "location access was denied") }
+            return
+        }
+        val fine = fine()
+        val high = "highAccuracyPosition" in listening && fine
+        // Registered even while location is off: updates start when it is turned on.
+        val provider = provider(lm, high, fine, enabledOnly = false) ?: return report(GeolocationErrorCode.NOT_FOUND, "no location provider")
+        val current = watch
+        if (current != null && current.provider == provider && current.high == high) return
+        stopWatch()
+        val listener = object : LocationListener {
+            override fun onLocationChanged(location: Location) {
+                lastReport = null
+                val fix = position(location)
+                for (event in listening.toList()) if (event == "highAccuracyPosition") events.highAccuracyPosition(fix) else events.position(fix)
+            }
+
+            override fun onProviderDisabled(provider: String) = report(GeolocationErrorCode.NOT_FOUND, "location is turned off")
+
+            override fun onProviderEnabled(provider: String) {
+                lastReport = null
+            }
+
+            @Deprecated("abstract before API 30, never called from 29 on")
+            override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
+        }
+        try {
+            val interval = if (high) 1_000L else 5_000L
+            when {
+                Build.VERSION.SDK_INT >= 31 -> Api31.requestUpdates(lm, provider, high, activity.mainExecutor, listener)
+                Build.VERSION.SDK_INT >= 30 -> Api30.requestUpdates(lm, provider, interval, activity.mainExecutor, listener)
+                else -> lm.requestLocationUpdates(provider, interval, 0f, listener, Looper.getMainLooper())
+            }
+            watch = Watch(provider, high, listener)
+        } catch (e: RuntimeException) { // SecurityException, IllegalArgumentException
+            Log.w("AkanNative", "geolocation: cannot watch $provider", e)
+            return report(if (e is SecurityException) GeolocationErrorCode.PERMISSION_DENIED else GeolocationErrorCode.NOT_FOUND, e.message ?: "cannot watch $provider")
+        }
+        if (!lm.isLocationEnabled) report(GeolocationErrorCode.NOT_FOUND, "location is turned off")
+    }
+
+    private fun stopWatch() {
+        val current = watch ?: return
+        manager?.removeUpdates(current.listener)
+        watch = null
+    }
+
+    /** Sends an "error" event, once per distinct problem until the next fix. */
+    private fun report(code: GeolocationErrorCode, message: String) {
+        val key = "${code.json} $message"
+        if (lastReport == key) return
+        lastReport = key
+        events.error(GeolocationError(code = code, message = message))
+    }
+
+    // ------------------------------------------------------------ Location → Position
+
+    /** Float → Double through its shortest decimal form: 3.9f stays 3.9, not 3.9000000953674316. */
+    private fun num(value: Float): Double = value.toString().toDouble()
+
+    private fun position(l: Location) = GeolocationPosition(
+        latitude = l.latitude,
+        longitude = l.longitude,
+        accuracy = num(l.accuracy),
+        altitude = if (l.hasAltitude()) l.altitude else null, // WGS84 ellipsoid, as W3C
+        altitudeAccuracy = if (l.hasVerticalAccuracy()) num(l.verticalAccuracyMeters) else null,
+        heading = if (l.hasBearing() && l.hasSpeed() && l.speed > 0f) num(l.bearing) else null,
+        speed = if (l.hasSpeed()) num(l.speed) else null,
+        timestamp = l.time.toDouble(), // epoch ms: exact in a Double, and written without a fraction
+    )
+
+    private object Api30 {
+        fun currentLocation(lm: LocationManager, provider: String, signal: CancellationSignal, executor: Executor, done: (Location?) -> Unit) =
+            lm.getCurrentLocation(provider, signal, executor, Consumer { done(it) })
+
+        fun requestUpdates(lm: LocationManager, provider: String, interval: Long, executor: Executor, listener: LocationListener) =
+            lm.requestLocationUpdates(provider, interval, 0f, executor, listener)
+    }
+
+    private object Api31 {
+        fun hasProvider(lm: LocationManager, provider: String): Boolean = lm.hasProvider(provider)
+
+        fun currentLocation(lm: LocationManager, provider: String, high: Boolean, timeout: Long, signal: CancellationSignal, executor: Executor, done: (Location?) -> Unit) {
+            val request = LocationRequest.Builder(0)
+                .setQuality(if (high) LocationRequest.QUALITY_HIGH_ACCURACY else LocationRequest.QUALITY_BALANCED_POWER_ACCURACY)
+                .setDurationMillis(timeout)
+                .build()
+            lm.getCurrentLocation(provider, request, signal, executor, Consumer { done(it) })
+        }
+
+        fun requestUpdates(lm: LocationManager, provider: String, high: Boolean, executor: Executor, listener: LocationListener) {
+            val request = LocationRequest.Builder(if (high) 1_000 else 5_000)
+                .setQuality(if (high) LocationRequest.QUALITY_HIGH_ACCURACY else LocationRequest.QUALITY_BALANCED_POWER_ACCURACY)
+                .setMinUpdateIntervalMillis(if (high) 500 else 2_000)
+                .build()
+            lm.requestLocationUpdates(provider, request, executor, listener)
+        }
+    }
+
+    private companion object {
+        val PERMISSIONS = arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION)
+        val EVENTS = setOf("position", "highAccuracyPosition")
+        val PROVIDERS = listOf(LocationManager.FUSED_PROVIDER, LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER, LocationManager.PASSIVE_PROVIDER)
+    }
+}

package/vendor/@akanjs/native/plugins/geolocation/ios/GeolocationPlugin.swift

@@ -0,0 +1,284 @@
+import CoreLocation
+import Foundation
+
+/// CoreLocation, when-in-use authorization only.
+/// Compared with tauri-plugins-workspace/plugins/geolocation/ios/Sources/GeolocationPlugin.swift:
+/// - Two managers: `single` answers getCurrentPosition with requestLocation(), `watcher` runs
+///   startUpdatingLocation() while the page listens. requestLocation() and startUpdatingLocation()
+///   on one manager interfere (a running update makes the one-shot request moot, and
+///   stopUpdatingLocation() is also how a pending requestLocation() is cancelled).
+/// - Instance authorizationStatus / accuracyAuthorization and locationManagerDidChangeAuthorization
+///   (iOS 14+); Tauri still uses the deprecated class method (its own TODO).
+/// - timeout and maximumAge are honored (Tauri ignores both on iOS); balanced accuracy is 100 m
+///   (Tauri: 1 km, which in a city is often just the cell tower).
+/// - Invalid CLLocation fields (negative accuracy, course, speed) become null instead of -1, and
+///   altitude is ellipsoidalAltitude (iOS 15+) so it means the same as on Android and in W3C.
+/// - kCLErrorLocationUnknown during a watch is transient (Apple: "keeps trying"), so it is not
+///   reported; for a one-shot request it ends the request with NOT_FOUND.
+/// - Asking without NSLocationWhenInUseUsageDescription does nothing (the prompt never appears), so
+///   it is checked first. Location services off system-wide reads as .denied.
+/// - Reduced accuracy (Precise Location off) is reported as precise: false; asking for temporary
+///   full accuracy needs NSLocationTemporaryUsageDescriptionDictionary and is not offered yet.
+/// Simulator: `xcrun simctl location <udid> set <lat>,<lon>`, `xcrun simctl privacy <udid> grant location <bundle id>`.
+/// Arguments arrive decoded and checked by the generated GeolocationPluginSpec (PL-10); the ranges
+/// of timeout and maximumAge are checked here.
+final class GeolocationPlugin: NSObject, GeolocationPluginSpec, CLLocationManagerDelegate {
+    static let id = "geolocation"
+
+    private final class Request {
+        let reply: AkanNativeReply<GeolocationPosition>
+        let high: Bool
+        let timeout: Double
+        let timer: DispatchWorkItem
+        var started = false
+
+        init(reply: AkanNativeReply<GeolocationPosition>, high: Bool, timeout: Double, timer: DispatchWorkItem) {
+            (self.reply, self.high, self.timeout, self.timer) = (reply, high, timeout, timer)
+        }
+    }
+
+    private static let watchEvents: Set<String> = ["position", "highAccuracyPosition"]
+    private let events: GeolocationEvents
+    private let single = CLLocationManager()
+    private let watcher = CLLocationManager()
+    private var requests: [Int: Request] = [:]
+    private var nextRequest = 0
+    private var singleRunning = false
+    private var singleHigh = false
+    private var permissionReplies: [AkanNativeReply<GeolocationLocationPermission>] = []
+    private var listening: Set<String> = []
+    private var watchRunning = false
+    private var reportedDenied = false
+
+    init(context: AkanNativePluginContext) {
+        events = GeolocationEvents(context)
+        super.init()
+        single.delegate = self // created on the main thread: delegate calls arrive on the main run loop
+        watcher.delegate = self
+    }
+
+    func checkPermission(_ reply: AkanNativeReply<GeolocationLocationPermission>) {
+        reply.resolve(permission())
+    }
+
+    func requestPermission(_ reply: AkanNativeReply<GeolocationLocationPermission>) {
+        guard single.authorizationStatus == .notDetermined else { return reply.resolve(permission()) }
+        guard Self.hasUsageDescription else { return reply.reject(.internalError, Self.missingUsage) }
+        permissionReplies.append(reply)
+        single.requestWhenInUseAuthorization() // answered in locationManagerDidChangeAuthorization
+    }
+
+    func startListening(_ event: String) {
+        guard Self.watchEvents.contains(event) else { return }
+        listening.insert(event)
+        updateWatch()
+    }
+
+    func stopListening(_ event: String) {
+        guard Self.watchEvents.contains(event) else { return }
+        listening.remove(event)
+        updateWatch()
+    }
+
+    // MARK: permission
+
+    private static let missingUsage = "Info.plist has no NSLocationWhenInUseUsageDescription"
+
+    private static var hasUsageDescription: Bool {
+        Bundle.main.object(forInfoDictionaryKey: "NSLocationWhenInUseUsageDescription") != nil
+    }
+
+    private var authorized: Bool {
+        let status = single.authorizationStatus
+        return status == .authorizedWhenInUse || status == .authorizedAlways
+    }
+
+    private func permission() -> GeolocationLocationPermission {
+        let state: GeolocationPermissionState =
+            switch single.authorizationStatus {
+            case .notDetermined: .prompt
+            case .denied, .restricted: .denied
+            default: .granted
+            }
+        return GeolocationLocationPermission(location: state, precise: authorized ? single.accuracyAuthorization == .fullAccuracy : nil)
+    }
+
+    private func authorizationChanged() {
+        if single.authorizationStatus == .notDetermined { return } // the initial callback, or still asking
+        let replies = permissionReplies
+        permissionReplies.removeAll()
+        let state = permission()
+        for reply in replies { reply.resolve(state) }
+        if authorized { reportedDenied = false }
+        startSingle()
+        updateWatch()
+    }
+
+    // MARK: getCurrentPosition
+
+    /// A non-negative number of ms, or the fallback when absent. JSON has no Infinity: it arrives as null.
+    private static func milliseconds<T>(_ value: Double?, _ name: String, _ fallback: Double, _ reply: AkanNativeReply<T>) -> Double? {
+        guard let value else { return fallback }
+        guard value >= 0 else {
+            reply.reject(.invalidArgs, "\(name) must be a number of ms >= 0")
+            return nil
+        }
+        return value
+    }
+
+    func getCurrentPosition(_ args: GeolocationPositionOptions, _ reply: AkanNativeReply<GeolocationPosition>) {
+        guard let timeout = Self.milliseconds(args.timeout, "timeout", 30_000, reply),
+              let maximumAge = Self.milliseconds(args.maximumAge, "maximumAge", 0, reply) else { return }
+        let high = args.enableHighAccuracy ?? false
+        if maximumAge > 0, authorized, let cached = watcher.location ?? single.location,
+            cached.horizontalAccuracy >= 0, -cached.timestamp.timeIntervalSinceNow * 1000 <= maximumAge
+        {
+            return reply.resolve(GeolocationPosition(cached))
+        }
+        let id = nextRequest
+        nextRequest += 1
+        let timer = DispatchWorkItem { [weak self] in MainActor.assumeIsolated { self?.timedOut(id) } }
+        requests[id] = Request(reply: reply, high: high, timeout: timeout, timer: timer)
+        startSingle()
+    }
+
+    private func startSingle() {
+        guard !requests.isEmpty else { return stopSingle() }
+        switch single.authorizationStatus {
+        case .notDetermined:
+            guard Self.hasUsageDescription else { return finishAll(.internalError, Self.missingUsage) }
+            single.requestWhenInUseAuthorization() // continues in authorizationChanged
+        case .denied, .restricted:
+            finishAll(.permissionDenied, "location access was denied")
+        default:
+            // Like W3C, the timeout runs from here: time spent on the permission prompt does not count.
+            for request in requests.values where !request.started {
+                request.started = true
+                DispatchQueue.main.asyncAfter(deadline: .now() + min(request.timeout, 86_400_000) / 1000, execute: request.timer)
+            }
+            let high = requests.values.contains { $0.high }
+            if singleRunning, singleHigh || !high { return } // the running request is good enough
+            if singleRunning { single.stopUpdatingLocation() } // restart with the better accuracy
+            single.desiredAccuracy = high ? kCLLocationAccuracyBest : kCLLocationAccuracyHundredMeters
+            singleHigh = high
+            singleRunning = true
+            single.requestLocation()
+        }
+    }
+
+    private func stopSingle() {
+        if singleRunning { single.stopUpdatingLocation() } // also cancels a pending requestLocation()
+        singleRunning = false
+    }
+
+    private func timedOut(_ id: Int) {
+        guard let request = requests.removeValue(forKey: id) else { return }
+        request.reply.reject(.notFound, "no position within \(Int(request.timeout)) ms")
+        if requests.isEmpty { stopSingle() }
+    }
+
+    private func finishAll(_ code: AkanNativeErrorCode?, _ message: String, fix: GeolocationPosition? = nil) {
+        let pending = requests.values
+        requests.removeAll()
+        singleRunning = false
+        for request in pending {
+            request.timer.cancel()
+            if let fix { request.reply.resolve(fix) } else if let code { request.reply.reject(code, message) }
+        }
+    }
+
+    // MARK: watch
+
+    private func updateWatch() {
+        guard !listening.isEmpty else {
+            if watchRunning { watcher.stopUpdatingLocation() }
+            watchRunning = false
+            reportedDenied = false
+            return
+        }
+        switch watcher.authorizationStatus {
+        case .notDetermined:
+            guard Self.hasUsageDescription else { return reportOnce(.internal, Self.missingUsage) }
+            watcher.requestWhenInUseAuthorization()
+        case .denied, .restricted:
+            if watchRunning { watcher.stopUpdatingLocation() }
+            watchRunning = false
+            reportOnce(.permissionDenied, "location access was denied")
+        default:
+            // Changing desiredAccuracy on a running manager applies right away.
+            watcher.desiredAccuracy = listening.contains("highAccuracyPosition") ? kCLLocationAccuracyBest : kCLLocationAccuracyHundredMeters
+            if !watchRunning { watcher.startUpdatingLocation() }
+            watchRunning = true
+        }
+    }
+
+    private func reportOnce(_ code: GeolocationErrorCode, _ message: String) {
+        guard !reportedDenied else { return }
+        reportedDenied = true
+        events.error(GeolocationError(code: code, message: message))
+    }
+
+    // MARK: CLLocationManagerDelegate (main thread, see init)
+
+    private func received(_ fix: GeolocationPosition, from manager: ObjectIdentifier) {
+        if manager == ObjectIdentifier(single) {
+            finishAll(nil, "", fix: fix)
+        } else if watchRunning {
+            for event in listening {
+                if event == "highAccuracyPosition" { events.highAccuracyPosition(fix) } else { events.position(fix) }
+            }
+        }
+    }
+
+    private func failed(_ code: Int, _ message: String, from manager: ObjectIdentifier) {
+        let denied = code == CLError.Code.denied.rawValue
+        if manager == ObjectIdentifier(single) {
+            finishAll(denied ? .permissionDenied : .notFound, denied ? "location access was denied" : "no position: \(message)")
+        } else if denied {
+            if watchRunning { watcher.stopUpdatingLocation() }
+            watchRunning = false
+            reportOnce(.permissionDenied, "location access was denied")
+        } else if code != CLError.Code.locationUnknown.rawValue {
+            events.error(GeolocationError(code: .notFound, message: "no position: \(message)"))
+        }
+    }
+
+    nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        let id = ObjectIdentifier(manager)
+        MainActor.assumeIsolated {
+            if id == ObjectIdentifier(single) { authorizationChanged() } // both managers report the same app-wide change
+        }
+    }
+
+    nonisolated func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        // The last one is the newest (Tauri's comment on capacitor using .first).
+        guard let location = locations.last, location.horizontalAccuracy >= 0 else { return }
+        let fix = GeolocationPosition(location)
+        let id = ObjectIdentifier(manager)
+        MainActor.assumeIsolated { received(fix, from: id) }
+    }
+
+    nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: any Error) {
+        let code = (error as? CLError)?.code.rawValue ?? -1
+        let message = error.localizedDescription
+        let id = ObjectIdentifier(manager)
+        MainActor.assumeIsolated { failed(code, message, from: id) }
+    }
+}
+
+private extension GeolocationPosition {
+    /// A CLLocation reduced to Sendable values where the delegate call arrives.
+    init(_ location: CLLocation) {
+        let vertical = location.verticalAccuracy > 0
+        self.init(
+            latitude: location.coordinate.latitude,
+            longitude: location.coordinate.longitude,
+            accuracy: location.horizontalAccuracy,
+            altitude: vertical ? location.ellipsoidalAltitude : nil,
+            altitudeAccuracy: vertical ? location.verticalAccuracy : nil,
+            heading: location.course >= 0 ? location.course : nil,
+            speed: location.speed >= 0 ? location.speed : nil,
+            timestamp: (location.timestamp.timeIntervalSince1970 * 1000).rounded()
+        )
+    }
+}

package/vendor/@akanjs/native/plugins/geolocation/native-plugin.json

@@ -0,0 +1,23 @@
+{
+  "id": "geolocation",
+  "apiVersion": 1,
+  "methods": ["getCurrentPosition", "checkPermission", "requestPermission"],
+  "events": ["position", "highAccuracyPosition", "error"],
+  "coalesce": ["position", "highAccuracyPosition"],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": null,
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "GeolocationPlugin",
+    "frameworks": ["CoreLocation"],
+    "infoPlist": {
+      "NSLocationWhenInUseUsageDescription": "Show where you are."
+    }
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.geolocation.GeolocationPlugin",
+    "permissions": ["android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"]
+  }
+}