@tokamakdev/plugin-location 0.1.0-beta.33

package/README.md

@@ -0,0 +1,19 @@
+# @tokamakdev/plugin-location
+
+Location for Tokamak applications and the web.
+
+```ts
+import { location } from "@tokamakdev/plugin-location";
+
+const position = await location.getCurrentPosition();
+
+const stop = location.watchPosition(
+  (next) => console.log(next.coords.latitude, next.coords.longitude),
+  console.error,
+);
+```
+
+The web implementation uses `navigator.geolocation`. Native Tokamak builds use
+Core Location on Apple platforms, `LocationManager` on Android, and WebView2's
+location implementation on Windows. Calling the API on a platform without
+location support throws `NotSupportedError`.

package/android/LocationPlugin.kt

@@ -0,0 +1,180 @@
+package com.tokamak.plugins.location
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.Bundle
+import android.os.CancellationSignal
+import android.os.Looper
+import com.tokamak.runtime.TokamakPlugin
+import com.tokamak.runtime.TokamakPluginError
+import com.tokamak.runtime.TokamakPluginReply
+
+internal class TokamakLocationPlugin(
+    private val activity: Activity,
+) : TokamakPlugin {
+    override val id = "location"
+
+    private val manager =
+        activity.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+    private val permissionRequests = mutableListOf<(Boolean) -> Unit>()
+
+    override fun call(method: String, arguments: Any?, reply: TokamakPluginReply) {
+        if (method != "getCurrentPosition") {
+            super.call(method, arguments, reply)
+            return
+        }
+        withPermission { granted ->
+            if (granted) currentPosition(reply) else reply(permissionDenied())
+        }
+    }
+
+    override fun subscribe(
+        method: String,
+        arguments: Any?,
+        reply: TokamakPluginReply,
+    ): () -> Unit {
+        if (method != "watchPosition") return super.subscribe(method, arguments, reply)
+        var cancelled = false
+        var stop = {}
+        withPermission { granted ->
+            if (!granted) {
+                reply(permissionDenied())
+            } else if (!cancelled) {
+                stop = watchPosition(reply)
+            }
+        }
+        return {
+            cancelled = true
+            stop()
+        }
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray,
+    ) {
+        if (requestCode != LOCATION_PERMISSION_REQUEST) return
+        val granted = grantResults.any { it == PackageManager.PERMISSION_GRANTED }
+        val requests = permissionRequests.toList()
+        permissionRequests.clear()
+        requests.forEach { it(granted) }
+    }
+
+    private fun withPermission(action: (Boolean) -> Unit) {
+        if (hasPermission()) {
+            action(true)
+            return
+        }
+        permissionRequests.add(action)
+        if (permissionRequests.size > 1) return
+        activity.requestPermissions(
+            arrayOf(
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+            ),
+            LOCATION_PERMISSION_REQUEST,
+        )
+    }
+
+    private fun hasPermission(): Boolean =
+        activity.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED ||
+            activity.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED
+
+    private fun currentPosition(reply: TokamakPluginReply) {
+        val provider = runCatching(::provider).getOrElse {
+            reply(locationFailure(it, "Location is unavailable"))
+            return
+        }
+        if (provider == null) {
+            reply(unavailable("No location provider is available"))
+            return
+        }
+        runCatching {
+            manager.getCurrentLocation(
+                provider,
+                CancellationSignal(),
+                activity.mainExecutor,
+            ) { location ->
+                if (location == null) reply(unavailable("Location is unavailable"))
+                else reply(Result.success(position(location)))
+            }
+        }.onFailure { reply(locationFailure(it, "Location is unavailable")) }
+    }
+
+    private fun watchPosition(reply: TokamakPluginReply): () -> Unit {
+        val provider = runCatching(::provider).getOrElse {
+            reply(locationFailure(it, "Location is unavailable"))
+            return {}
+        }
+        if (provider == null) {
+            reply(unavailable("No location provider is available"))
+            return {}
+        }
+        val listener = object : LocationListener {
+            override fun onLocationChanged(location: Location) {
+                reply(Result.success(position(location)))
+            }
+
+            override fun onProviderDisabled(provider: String) {
+                reply(unavailable("Location provider is unavailable"))
+            }
+
+            override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) = Unit
+        }
+        val started = runCatching {
+            manager.requestLocationUpdates(provider, 1000, 0F, listener, Looper.getMainLooper())
+        }
+        if (started.isFailure) {
+            reply(locationFailure(started.exceptionOrNull(), "Location is unavailable"))
+            return {}
+        }
+        return { manager.removeUpdates(listener) }
+    }
+
+    private fun provider(): String? =
+        listOf(
+            LocationManager.GPS_PROVIDER,
+            LocationManager.NETWORK_PROVIDER,
+            LocationManager.FUSED_PROVIDER,
+        ).firstOrNull(manager::isProviderEnabled)
+            ?: manager.getProviders(true).firstOrNull()
+
+    private fun position(location: Location): Map<String, Any?> =
+        mapOf(
+            "coords" to
+                mapOf(
+                    "latitude" to location.latitude,
+                    "longitude" to location.longitude,
+                    "accuracy" to location.accuracy.toDouble(),
+                    "altitude" to location.altitude.takeIf { location.hasAltitude() },
+                    "altitudeAccuracy" to
+                        location.verticalAccuracyMeters.toDouble()
+                            .takeIf { location.hasVerticalAccuracy() },
+                    "heading" to location.bearing.toDouble().takeIf { location.hasBearing() },
+                    "speed" to location.speed.toDouble().takeIf { location.hasSpeed() },
+                ),
+            "timestamp" to location.time,
+        )
+
+    private fun permissionDenied(): Result<Any?> =
+        Result.failure(TokamakPluginError("NotAllowedError", "Location permission was denied"))
+
+    private fun unavailable(message: String): Result<Any?> =
+        Result.failure(TokamakPluginError("NotReadableError", message))
+
+    private fun locationFailure(error: Throwable?, fallback: String): Result<Any?> =
+        if (error is SecurityException) permissionDenied()
+        else unavailable(error?.message ?: fallback)
+
+    private companion object {
+        const val LOCATION_PERMISSION_REQUEST = 0xA771
+    }
+}

package/apple/LocationPlugin.swift

@@ -0,0 +1,174 @@
+import CoreLocation
+import Foundation
+
+final class TokamakLocationPlugin: NSObject, TokamakPlugin,
+  CLLocationManagerDelegate
+{
+  let id = "location"
+
+  private let manager = CLLocationManager()
+  private var current: [TokamakPluginReply] = []
+  private var watchers: [UUID: TokamakPluginReply] = [:]
+
+  override init() {
+    super.init()
+    manager.delegate = self
+    manager.desiredAccuracy = kCLLocationAccuracyBest
+  }
+
+  func call(
+    method: String,
+    arguments: Any,
+    reply: @escaping TokamakPluginReply
+  ) {
+    guard method == "getCurrentPosition" else {
+      reply(.failure(.notSupported("\(id).\(method) is not supported")))
+      return
+    }
+    current.append(reply)
+    start()
+  }
+
+  func subscribe(
+    method: String,
+    arguments: Any,
+    reply: @escaping TokamakPluginReply
+  ) -> (() -> Void) {
+    guard method == "watchPosition" else {
+      reply(.failure(.notSupported("\(id).\(method) is not supported")))
+      return {}
+    }
+    let subscription = UUID()
+    watchers[subscription] = reply
+    start()
+    return { [weak self] in
+      self?.watchers.removeValue(forKey: subscription)
+      self?.stopIfIdle()
+    }
+  }
+
+  func locationManagerDidChangeAuthorization(
+    _ manager: CLLocationManager
+  ) {
+    switch manager.authorizationStatus {
+    case .authorizedAlways, .authorizedWhenInUse:
+      manager.startUpdatingLocation()
+    case .denied, .restricted:
+      fail(
+        TokamakPluginError(
+          name: "NotAllowedError",
+          message: "Location permission was denied"
+        ))
+    case .notDetermined:
+      break
+    @unknown default:
+      fail(.notSupported("Location authorization is not supported"))
+    }
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didUpdateLocations locations: [CLLocation]
+  ) {
+    guard let location = locations.last else { return }
+    let result = Result<Any?, TokamakPluginError>.success(position(location))
+    let waiting = current
+    current.removeAll()
+    for reply in waiting {
+      reply(result)
+    }
+    for reply in watchers.values {
+      reply(result)
+    }
+    stopIfIdle()
+  }
+
+  func locationManager(
+    _ manager: CLLocationManager,
+    didFailWithError error: Error
+  ) {
+    if (error as NSError).code == CLError.Code.locationUnknown.rawValue {
+      return
+    }
+    fail(locationError(error))
+  }
+
+  private func start() {
+    guard CLLocationManager.locationServicesEnabled() else {
+      fail(unavailable("Location services are disabled"))
+      return
+    }
+    switch manager.authorizationStatus {
+    case .authorizedAlways, .authorizedWhenInUse:
+      manager.startUpdatingLocation()
+    case .notDetermined:
+      manager.requestWhenInUseAuthorization()
+    case .denied, .restricted:
+      fail(
+        TokamakPluginError(
+          name: "NotAllowedError",
+          message: "Location permission was denied"
+        ))
+    @unknown default:
+      fail(.notSupported("Location authorization is not supported"))
+    }
+  }
+
+  private func fail(_ error: TokamakPluginError) {
+    let result = Result<Any?, TokamakPluginError>.failure(error)
+    let replies = current + Array(watchers.values)
+    current.removeAll()
+    for reply in replies {
+      reply(result)
+    }
+    if watchers.isEmpty {
+      manager.stopUpdatingLocation()
+    }
+  }
+
+  private func locationError(_ error: Error) -> TokamakPluginError {
+    if (error as NSError).code == CLError.Code.denied.rawValue {
+      return TokamakPluginError(
+        name: "NotAllowedError",
+        message: "Location permission was denied"
+      )
+    }
+    return unavailable(error.localizedDescription)
+  }
+
+  private func unavailable(_ message: String) -> TokamakPluginError {
+    TokamakPluginError(name: "NotReadableError", message: message)
+  }
+
+  private func stopIfIdle() {
+    if current.isEmpty && watchers.isEmpty {
+      manager.stopUpdatingLocation()
+    }
+  }
+
+  private func position(_ location: CLLocation) -> [String: Any] {
+    let coordinates = location.coordinate
+    return [
+      "coords": [
+        "latitude": coordinates.latitude,
+        "longitude": coordinates.longitude,
+        "accuracy": location.horizontalAccuracy,
+        "altitude": nullable(
+          location.verticalAccuracy >= 0,
+          location.altitude
+        ),
+        "altitudeAccuracy": nullable(
+          location.verticalAccuracy >= 0,
+          location.verticalAccuracy
+        ),
+        "heading": nullable(location.course >= 0, location.course),
+        "speed": nullable(location.speed >= 0, location.speed),
+      ],
+      "timestamp": location.timestamp.timeIntervalSince1970 * 1000,
+    ]
+  }
+
+  private func nullable(_ available: Bool, _ value: Double) -> Any {
+    available ? value : NSNull()
+  }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@tokamakdev/plugin-location",
+  "version": "0.1.0-beta.33",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mantty/tokamak.git",
+    "directory": "plugins/location"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@tokamakdev/plugin": "0.1.0-beta.33"
+  },
+  "files": [
+    "android",
+    "apple",
+    "src",
+    "web",
+    "tokamak-plugin.json",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+import { FrontendPlugin } from "@tokamakdev/plugin";
+import * as web from "../web/index.js";
+
+export interface Coordinates {
+  readonly latitude: number;
+  readonly longitude: number;
+  readonly accuracy: number;
+  readonly altitude: number | null;
+  readonly altitudeAccuracy: number | null;
+  readonly heading: number | null;
+  readonly speed: number | null;
+}
+
+export interface Position {
+  readonly coords: Coordinates;
+  readonly timestamp: number;
+}
+
+export type PositionCallback = (position: Position) => void;
+export type PositionErrorCallback = (error: DOMException) => void;
+
+class Location extends FrontendPlugin {
+  constructor() {
+    super("location");
+  }
+
+  getCurrentPosition(): Promise<Position> {
+    if (this.hasNativeTransport) {
+      return this.call("getCurrentPosition");
+    }
+    return web.getCurrentPosition();
+  }
+
+  watchPosition(next: PositionCallback, error: PositionErrorCallback): () => void {
+    if (this.hasNativeTransport) {
+      return this.subscribe("watchPosition", (position) => {
+        next(position as Position);
+      }, error);
+    }
+    return web.watchPosition(next, error);
+  }
+}
+
+export const location = new Location();

package/tokamak-plugin.json

@@ -0,0 +1,39 @@
+{
+  "schemaVersion": 1,
+  "id": "location",
+  "kind": "frontend",
+  "platforms": {
+    "macos": {
+      "class": "TokamakLocationPlugin",
+      "sources": ["apple/LocationPlugin.swift"],
+      "frameworks": ["CoreLocation"],
+      "plist": {
+        "NSLocationUsageDescription": "This app uses your location when you request location features."
+      }
+    },
+    "ios": {
+      "class": "TokamakLocationPlugin",
+      "sources": ["apple/LocationPlugin.swift"],
+      "frameworks": ["CoreLocation"],
+      "plist": {
+        "NSLocationWhenInUseUsageDescription": "This app uses your location when you request location features."
+      }
+    },
+    "ios-simulator": {
+      "class": "TokamakLocationPlugin",
+      "sources": ["apple/LocationPlugin.swift"],
+      "frameworks": ["CoreLocation"],
+      "plist": {
+        "NSLocationWhenInUseUsageDescription": "This app uses your location when you request location features."
+      }
+    },
+    "android": {
+      "class": "com.tokamak.plugins.location.TokamakLocationPlugin",
+      "sources": ["android/LocationPlugin.kt"],
+      "permissions": [
+        "android.permission.ACCESS_COARSE_LOCATION",
+        "android.permission.ACCESS_FINE_LOCATION"
+      ]
+    }
+  }
+}

package/web/index.ts

@@ -0,0 +1,65 @@
+import type { Position, PositionCallback, PositionErrorCallback } from "../src/index.js";
+
+export function getCurrentPosition(): Promise<Position> {
+  return new Promise((resolve, reject) => {
+    const browserLocation = browserLocationApi();
+    browserLocation.getCurrentPosition(
+      (position) => {
+        resolve(copyPosition(position));
+      },
+      (error) => {
+        reject(positionError(error));
+      },
+    );
+  });
+}
+
+export function watchPosition(
+  next: PositionCallback,
+  error: PositionErrorCallback,
+): () => void {
+  const browserLocation = browserLocationApi();
+  const id = browserLocation.watchPosition(
+    (position) => {
+      next(copyPosition(position));
+    },
+    (failure) => {
+      error(positionError(failure));
+    },
+  );
+  return () => {
+    browserLocation.clearWatch(id);
+  };
+}
+
+function browserLocationApi(): Geolocation {
+  const root: { navigator?: { geolocation?: Geolocation } } = globalThis;
+  const browserLocation = root.navigator?.geolocation;
+  if (browserLocation) return browserLocation;
+  throw new DOMException("Location is unavailable", "NotSupportedError");
+}
+
+function copyPosition(position: GeolocationPosition): Position {
+  const { coords } = position;
+  return {
+    coords: {
+      latitude: coords.latitude,
+      longitude: coords.longitude,
+      accuracy: coords.accuracy,
+      altitude: coords.altitude,
+      altitudeAccuracy: coords.altitudeAccuracy,
+      heading: coords.heading,
+      speed: coords.speed,
+    },
+    timestamp: position.timestamp,
+  };
+}
+
+function positionError(error: GeolocationPositionError): DOMException {
+  const name = {
+    [error.PERMISSION_DENIED]: "NotAllowedError",
+    [error.POSITION_UNAVAILABLE]: "NotReadableError",
+    [error.TIMEOUT]: "TimeoutError",
+  }[error.code];
+  return new DOMException(error.message, name ?? "UnknownError");
+}