@detonator/location 1.0.0

package/android/DetonatorLocation/build.gradle

@@ -0,0 +1,38 @@
+plugins {
+    alias(libs.plugins.androidLibrary)
+}
+
+android {
+    namespace 'com.iconshot.detonator.location'
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 29
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles "consumer-rules.pro"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+}
+
+dependencies {
+    implementation project(':Detonator')
+
+    implementation "com.google.android.gms:play-services-location:21.3.0"
+
+    implementation libs.appcompat
+    implementation libs.material
+    testImplementation libs.junit
+    androidTestImplementation libs.ext.junit
+    androidTestImplementation libs.espresso.core
+}

package/android/DetonatorLocation/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

package/android/DetonatorLocation/src/androidTest/java/com/iconshot/detonator/location/ExampleInstrumentedTest.java

@@ -0,0 +1,26 @@
+package com.iconshot.detonator.location;
+
+import android.content.Context;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
+        assertEquals("com.iconshot.detonator.location.test", appContext.getPackageName());
+    }
+}

package/android/DetonatorLocation/src/main/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+
+    <application>
+        <activity android:name=".LocationActivity"
+            android:exported="false"/>
+    </application>
+</manifest>

package/android/DetonatorLocation/src/main/java/com/iconshot/detonator/location/LocationActivity.java

@@ -0,0 +1,58 @@
+package com.iconshot.detonator.location;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+
+import java.util.function.Consumer;
+
+public class LocationActivity extends Activity {
+    public static Consumer<Boolean> permissionResultCallback;
+
+    public static Boolean background;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // activities get recreated on permission downgrade (e.g. Allow in use -> Don't allow)
+
+        if (background == null) {
+            finish();
+
+            return;
+        }
+
+        if (background) {
+            ActivityCompat.requestPermissions(
+                    this,
+                    new String[]{Manifest.permission.ACCESS_BACKGROUND_LOCATION},
+                    100
+            );
+        } else {
+            ActivityCompat.requestPermissions(
+                    this,
+                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
+                    100
+            );
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
+                                           @NonNull int[] grantResults) {
+        boolean hasGrantedLocationPermission = grantResults[0] == PackageManager.PERMISSION_GRANTED;
+
+        boolean permissionsGranted = hasGrantedLocationPermission;
+
+        if (permissionResultCallback != null) {
+            permissionResultCallback.accept(permissionsGranted);
+        }
+
+        finish();
+    }
+}

package/android/DetonatorLocation/src/main/java/com/iconshot/detonator/location/LocationModule.java

@@ -0,0 +1,155 @@
+package com.iconshot.detonator.location;
+
+import android.Manifest;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+
+import androidx.core.content.ContextCompat;
+
+import com.google.android.gms.location.FusedLocationProviderClient;
+import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.location.Priority;
+import com.google.android.gms.tasks.CancellationTokenSource;
+import com.iconshot.detonator.Detonator;
+import com.iconshot.detonator.module.Module;
+
+public class LocationModule extends Module {
+    private FusedLocationProviderClient locationClient;
+
+    public LocationModule(Detonator detonator) {
+        super(detonator);
+    }
+
+    @Override
+    public void setUp() {
+        locationClient = LocationServices.getFusedLocationProviderClient(detonator.context);
+
+        detonator.setRequestListener("com.iconshot.detonator.location::requestPermission", (promise, value, edge) -> {
+            RequestPermissionOptions options = detonator.decode(value, RequestPermissionOptions.class);
+
+            boolean permissionGranted = options.background
+                    ? ContextCompat.checkSelfPermission(
+                        detonator.context,
+                        Manifest.permission.ACCESS_BACKGROUND_LOCATION
+                    ) == PackageManager.PERMISSION_GRANTED
+                    : ContextCompat.checkSelfPermission(
+                        detonator.context,
+                        Manifest.permission.ACCESS_FINE_LOCATION
+                    ) == PackageManager.PERMISSION_GRANTED;
+
+            if (permissionGranted) {
+                promise.resolve(true);
+
+                return;
+            }
+
+            LocationActivity.background = options.background;
+
+            LocationActivity.permissionResultCallback = granted -> {
+                promise.resolve(granted);
+            };
+
+            detonator.context.startActivity(new Intent(detonator.context, LocationActivity.class));
+        });
+
+        detonator.setRequestListener("com.iconshot.detonator.location::getLocation", (promise, value, edge) -> {
+            GetLocationOptions options = detonator.decode(value, GetLocationOptions.class);
+
+            CancellationTokenSource token = new CancellationTokenSource();
+
+            Runnable timeoutRunnable = () -> {
+                token.cancel();
+
+                promise.reject("Location request timed out.");
+            };
+
+            detonator.uiHandler.postDelayed(timeoutRunnable, options.timeout);
+
+            locationClient.getCurrentLocation(
+                    options.accurate
+                            ? Priority.PRIORITY_HIGH_ACCURACY
+                            : Priority.PRIORITY_BALANCED_POWER_ACCURACY,
+                    token.getToken()
+            ).addOnSuccessListener(location -> {
+                detonator.uiHandler.removeCallbacks(timeoutRunnable);
+
+                token.cancel();
+
+                if (location == null) {
+                    promise.reject("Location not available.");
+
+                    return;
+                }
+
+                if (!location.hasAccuracy()) {
+                    promise.reject("Location lacks accuracy.");
+
+                    return;
+                }
+
+                if (location.getAccuracy() > options.maxAccuracy) {
+                    promise.reject("Location not accurate enough.");
+
+                    return;
+                }
+
+                long age = System.currentTimeMillis() - location.getTime();
+
+                if (age > options.maxAge) {
+                    promise.reject("Location too old.");
+
+                    return;
+                }
+
+                LocationData data = new LocationData();
+
+                data.latitude = location.getLatitude();
+                data.longitude = location.getLongitude();
+                data.altitude = location.hasAltitude() ? location.getAltitude() : null;
+                data.accuracy = location.hasAccuracy() ? location.getAccuracy() : null;
+                data.speed = location.hasSpeed() ? location.getSpeed() : null;
+                data.time = location.getTime();
+                data.bearing = location.hasBearing() ? location.getBearing() : null;
+                data.provider = location.getProvider();
+
+                data.verticalAccuracy = location.hasVerticalAccuracy()
+                        ? location.getVerticalAccuracyMeters()
+                        : null;
+
+                data.course = data.bearing;
+
+                promise.resolve(data);
+            }).addOnFailureListener(error -> {
+                detonator.uiHandler.removeCallbacks(timeoutRunnable);
+
+                token.cancel();
+
+                promise.reject("Location not available.");
+            });
+        });
+    }
+
+    public static class RequestPermissionOptions {
+        boolean background;
+    }
+
+    public static class GetLocationOptions {
+        boolean accurate;
+        int maxAge;
+        double maxAccuracy;
+        int timeout;
+    }
+
+    public static class LocationData {
+        double latitude;
+        double longitude;
+        Double altitude;
+        Float accuracy;
+        Float speed;
+        long time;
+        Float bearing;
+        String provider;
+        Float verticalAccuracy;
+        Float course;
+    }
+}

package/android/DetonatorLocation/src/test/java/com/iconshot/detonator/location/ExampleUnitTest.java

@@ -0,0 +1,17 @@
+package com.iconshot.detonator.location;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+public class ExampleUnitTest {
+    @Test
+    public void addition_isCorrect() {
+        assertEquals(4, 2 + 2);
+    }
+}

package/dist/esm/Location.d.ts

@@ -0,0 +1,23 @@
+export interface LocationData {
+    latitude: number;
+    longitude: number;
+    altitude: number | null;
+    accuracy: number | null;
+    speed: number | null;
+    time: number;
+    bearing: number | null;
+    provider: string | null;
+    verticalAccuracy: number | null;
+    course: number | null;
+}
+export declare class Location {
+    static requestPermission(options?: Partial<{
+        background: boolean;
+    }>): Promise<boolean>;
+    static getLocation(options?: Partial<{
+        accurate: boolean;
+        maxAge: number;
+        maxAccuracy: number;
+        timeout: number;
+    }>): Promise<LocationData>;
+}

package/dist/esm/Location.js

@@ -0,0 +1,21 @@
+import Detonator, { Platform } from "detonator";
+export class Location {
+    static async requestPermission(options = {}) {
+        const tmpOptions = { ...options };
+        tmpOptions.background = options.background ?? false;
+        return await Detonator.request("com.iconshot.detonator.location::requestPermission", tmpOptions).fetchAndDecode();
+    }
+    static async getLocation(options = {}) {
+        const tmpOptions = { ...options };
+        tmpOptions.accurate = options.accurate ?? false;
+        if (Platform.get() === "ios") {
+            tmpOptions.accurate = true;
+        }
+        tmpOptions.maxAge = options.maxAge ?? 15000;
+        tmpOptions.maxAccuracy =
+            options.maxAccuracy ?? (tmpOptions.accurate ? 60 : 200);
+        tmpOptions.timeout =
+            options.timeout ?? (tmpOptions.accurate ? 20000 : 10000);
+        return await Detonator.request("com.iconshot.detonator.location::getLocation", tmpOptions).fetchAndDecode();
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export * from "./Location";

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from "./Location";

package/ios/DetonatorLocation/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.10
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "DetonatorLocation",
+    platforms: [
+        .iOS(.v13),
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "DetonatorLocation",
+            targets: ["DetonatorLocation"]),
+    ],
+    dependencies: [
+        .package(name: "Detonator", path: "../../../../../node_modules/detonator/ios/Detonator")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "DetonatorLocation",
+            dependencies: ["Detonator"]),
+
+    ]
+)

package/ios/DetonatorLocation/Sources/DetonatorLocation/LocationGetter.swift

@@ -0,0 +1,124 @@
+import CoreLocation
+
+import Detonator
+
+public class LocationGetter: NSObject, CLLocationManagerDelegate {
+    private let locationManager = CLLocationManager()
+    
+    private let promise: RequestPromise
+    private let options: GetLocationOptions
+    
+    private var timeoutTimer: Timer?
+    private var fulfillTimer: Timer?
+    
+    private var ended: Bool = false
+    
+    public var onEnded: (() -> Void)!
+
+    init(_ promise: RequestPromise, _ options: GetLocationOptions) {
+        self.promise = promise
+        self.options = options
+        
+        super.init()
+
+        locationManager.delegate = self
+    }
+    
+    public func run() -> Void {
+        timeoutTimer = Timer.scheduledTimer(
+            withTimeInterval: TimeInterval(options.timeout) / 1000.0,
+            repeats: false
+        ) { _ in
+            self.timeoutTimer?.invalidate()
+            
+            self.promise.reject("Location request timed out.")
+            
+            self.end()
+        }
+        
+        locationManager.requestLocation()
+    }
+    
+    private func end() -> Void {
+        ended = true
+        
+        onEnded()
+    }
+    
+    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        if ended {
+            return
+        }
+        
+        timeoutTimer?.invalidate()
+        
+        fulfillTimer?.invalidate()
+        
+        fulfillTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { _ in
+            guard let location = locations.last else {
+                self.promise.reject("Location not available.")
+                
+                self.end()
+                
+                return
+            }
+            
+            if location.horizontalAccuracy < 0 {
+                self.promise.reject("Location lacks accuracy.")
+                
+                self.end()
+                
+                return
+            }
+            
+            if Double(location.horizontalAccuracy) > self.options.maxAccuracy {
+                self.promise.reject("Location not accurate enough.")
+                
+                self.end()
+                
+                return
+            }
+            
+            let age = Int(Date().timeIntervalSince1970 * 1000) - Int(location.timestamp.timeIntervalSince1970 * 1000)
+            
+            if age > self.options.maxAge {
+                self.promise.reject("Location too old.")
+                
+                self.end()
+                
+                return
+            }
+            
+            let data = LocationData(
+                latitude: location.coordinate.latitude,
+                longitude: location.coordinate.longitude,
+                altitude: location.verticalAccuracy < 0 ? nil : location.altitude,
+                accuracy: location.horizontalAccuracy,
+                speed: location.speed >= 0 ? location.speed : nil,
+                time: Int(location.timestamp.timeIntervalSince1970 * 1000),
+                bearing: location.course >= 0 ? location.course : nil,
+                provider: "Apple",
+                verticalAccuracy: location.verticalAccuracy >= 0 ? location.verticalAccuracy : nil,
+                course: location.course >= 0 ? location.course : nil,
+            )
+            
+            self.promise.resolve(data)
+            
+            self.end()
+        }
+    }
+    
+    // either update or failure will happen, not both
+    
+    public func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        if ended {
+            return
+        }
+        
+        timeoutTimer?.invalidate()
+        
+        promise.reject("Location not available.")
+        
+        end()
+    }
+}

package/ios/DetonatorLocation/Sources/DetonatorLocation/LocationModule.swift

@@ -0,0 +1,154 @@
+import Foundation
+import UIKit
+import CoreLocation
+
+import Detonator
+
+public class LocationModule: Module, CLLocationManagerDelegate {
+    private let locationManager = CLLocationManager()
+    
+    private var requestPermissionPromise: RequestPromise?
+    private var requestPermissionBackground: Bool?
+    private var requestPermissionTimer: Timer?
+    
+    private var locationGetters: [LocationGetter] = []
+    
+    public override func setUp() -> Void {
+        locationManager.delegate = self
+        
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.permissionDialogOpened),
+            name: UIApplication.willResignActiveNotification,
+            object: nil
+        )
+        
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.permissionDialogClosed),
+            name: UIApplication.didBecomeActiveNotification,
+            object: nil
+        )
+        
+        detonator.setRequestListener("com.iconshot.detonator.location::requestPermission") { promise, value, edge in
+            let options: RequestPermissionOptions = self.detonator.decode(value)!
+            
+            let status = CLLocationManager.authorizationStatus()
+            
+            if options.background {
+                if status == .authorizedAlways {
+                    promise.resolve(true)
+                    
+                    return
+                }
+            } else {
+                if status == .authorizedWhenInUse || status == .authorizedAlways {
+                    promise.resolve(true)
+                    
+                    return
+                }
+            }
+            
+            if status == .denied || status == .restricted {
+                promise.resolve(false)
+                
+                return
+            }
+            
+            self.requestPermissionPromise = promise
+            self.requestPermissionBackground = options.background
+            
+            if options.background {
+                self.locationManager.requestAlwaysAuthorization()
+                
+                self.requestPermissionTimer = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: false) { _ in
+                    self.resolveBackgroundRequestPermissionIfDialogNotOpened()
+                }
+            } else {
+                self.locationManager.requestWhenInUseAuthorization()
+            }
+        }
+        
+        detonator.setRequestListener("com.iconshot.detonator.location::getLocation") { promise, value, edge in
+            let options: GetLocationOptions = self.detonator.decode(value)!
+                        
+            let locationGetter = LocationGetter(promise, options)
+            
+            self.locationGetters.append(locationGetter)
+                        
+            locationGetter.onEnded = {
+                self.locationGetters.removeAll { $0 === locationGetter }
+            }
+            
+            locationGetter.run()
+        }
+    }
+    
+    @objc private func permissionDialogOpened() {
+        guard let requestPermissionPromise = self.requestPermissionPromise else {
+            return
+        }
+        
+        self.requestPermissionTimer?.invalidate()
+        
+        self.requestPermissionTimer = nil
+    }
+    
+    @objc private func permissionDialogClosed() {
+        guard
+            let requestPermissionPromise = self.requestPermissionPromise,
+            let requestPermissionBackground = self.requestPermissionBackground
+        else {
+            return
+        }
+        
+        let status = CLLocationManager.authorizationStatus()
+        
+        let granted = requestPermissionBackground
+        ? status == .authorizedAlways
+        : status == .authorizedWhenInUse || status == .authorizedAlways
+        
+        requestPermissionPromise.resolve(granted)
+        
+        self.requestPermissionPromise = nil
+        self.requestPermissionBackground = nil
+    }
+    
+    private func resolveBackgroundRequestPermissionIfDialogNotOpened() {
+        guard let requestPermissionPromise = self.requestPermissionPromise else {
+            return
+        }
+        
+        requestPermissionPromise.resolve(false)
+        
+        self.requestPermissionTimer?.invalidate()
+        
+        self.requestPermissionPromise = nil
+        self.requestPermissionBackground = nil
+        self.requestPermissionTimer = nil
+    }
+}
+
+private struct RequestPermissionOptions: Decodable {
+    let background: Bool
+}
+
+public struct GetLocationOptions: Decodable {
+    let accurate: Bool
+    let maxAge: Int
+    let maxAccuracy: Double
+    let timeout: Int
+}
+
+public struct LocationData: Encodable {
+    let latitude: Double
+    let longitude: Double
+    let altitude: Double?
+    let accuracy: Double?
+    let speed: Double?
+    let time: Int
+    let bearing: Double?
+    let provider: String?
+    let verticalAccuracy: Double?
+    let course: Double?
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@detonator/location",
+  "version": "1.0.0",
+  "description": "Location module for Detonator.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iconshot/detonator-location.git"
+  },
+  "type": "module",
+  "main": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "scripts": {
+    "remove-dist": "rm -rf dist",
+    "bundle-dist": "npm run remove-dist && tsc",
+    "build": "npm run bundle-dist",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "location",
+    "detonator",
+    "untrue"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "detonator": "^1.11.2",
+    "untrue": "^5.18.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}