react-native-nitro-geolocation 1.2.5 → 1.3.0

package/android/src/main/java/com/margelo/nitro/nitrogeolocation/background/NitroLocationUpdateReceiver.kt

@@ -0,0 +1,37 @@
+package com.margelo.nitro.nitrogeolocation.background
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.location.Location
+import android.location.LocationManager
+import android.os.Build
+import com.google.android.gms.location.LocationResult
+import com.margelo.nitro.nitrogeolocation.BackgroundLocationSource
+
+class NitroLocationUpdateReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val controller = NitroBackgroundLocationController.getInstance(context)
+        val platformLocation = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            intent.getParcelableExtra(LocationManager.KEY_LOCATION_CHANGED, Location::class.java)
+        } else {
+            @Suppress("DEPRECATION")
+            intent.getParcelableExtra(LocationManager.KEY_LOCATION_CHANGED) as? Location
+        }
+        if (platformLocation != null) {
+            controller.handleNativeLocation(
+                platformLocation,
+                BackgroundLocationSource.FOREGROUNDSERVICE
+            )
+            return
+        }
+
+        val result = LocationResult.extractResult(intent) ?: return
+        for (location in result.locations) {
+            controller.handleNativeLocation(
+                location,
+                BackgroundLocationSource.FOREGROUNDSERVICE
+            )
+        }
+    }
+}

package/android/src/test/java/com/margelo/nitro/nitrogeolocation/AndroidFusedLocationProviderTest.kt

@@ -0,0 +1,64 @@
+package com.margelo.nitro.nitrogeolocation
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AndroidFusedLocationProviderTest {
+    @Test
+    fun initialUpdateMaxAgeHonorsMaxUpdateAgeWithoutMaximumAge() {
+        assertEquals(
+            60_000.0,
+            fusedInitialUpdateMaxAge(
+                options = parsedOptions(maximumAge = 0.0, maxUpdateAge = 60_000.0),
+                effectiveMaximumAge = 0.0
+            ),
+            0.0
+        )
+    }
+
+    @Test
+    fun initialUpdateMaxAgeUsesEffectiveMaximumAgeWhenMaxUpdateAgeIsAbsent() {
+        assertEquals(
+            30_000.0,
+            fusedInitialUpdateMaxAge(
+                options = parsedOptions(maximumAge = 30_000.0, maxUpdateAge = null),
+                effectiveMaximumAge = 30_000.0
+            ),
+            0.0
+        )
+    }
+
+    @Test
+    fun initialUpdateMaxAgePreservesExplicitZeroMaxUpdateAge() {
+        assertEquals(
+            0.0,
+            fusedInitialUpdateMaxAge(
+                options = parsedOptions(maximumAge = 60_000.0, maxUpdateAge = 0.0),
+                effectiveMaximumAge = 0.0
+            ),
+            0.0
+        )
+    }
+
+    private fun parsedOptions(
+        maximumAge: Double,
+        maxUpdateAge: Double?
+    ): ParsedOptions {
+        return ParsedOptions(
+            timeout = 10_000.0,
+            maximumAge = maximumAge,
+            androidAccuracy = AndroidAccuracyResolution(
+                mode = AndroidAccuracyMode.BALANCED,
+                explicitPreset = null
+            ),
+            interval = 1_000.0,
+            fastestInterval = 100.0,
+            distanceFilter = 0.0,
+            granularity = AndroidGranularity.PERMISSION,
+            waitForAccurateLocation = false,
+            maxUpdateAge = maxUpdateAge,
+            maxUpdateDelay = 0.0,
+            maxUpdates = null
+        )
+    }
+}

package/android/src/test/java/com/margelo/nitro/nitrogeolocation/AndroidProviderRouteTest.kt

@@ -0,0 +1,116 @@
+package com.margelo.nitro.nitrogeolocation
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class AndroidProviderRouteTest {
+    @Test
+    fun autoPrefersFusedWhenGooglePlayServicesAreAvailable() {
+        assertEquals(
+            AndroidProviderRoute.FUSED,
+            selectAndroidProviderRoute(
+                locationProvider = LocationProvider.AUTO,
+                googlePlayServicesAvailable = true
+            )
+        )
+    }
+
+    @Test
+    fun playServicesPrefersFusedWhenGooglePlayServicesAreAvailable() {
+        assertEquals(
+            AndroidProviderRoute.FUSED,
+            selectAndroidProviderRoute(
+                locationProvider = LocationProvider.PLAYSERVICES,
+                googlePlayServicesAvailable = true
+            )
+        )
+    }
+
+    @Test
+    fun autoFallsBackToPlatformWhenGooglePlayServicesAreUnavailable() {
+        assertEquals(
+            AndroidProviderRoute.PLATFORM,
+            selectAndroidProviderRoute(
+                locationProvider = LocationProvider.AUTO,
+                googlePlayServicesAvailable = false
+            )
+        )
+    }
+
+    @Test
+    fun playServicesFallsBackToPlatformWhenGooglePlayServicesAreUnavailable() {
+        assertEquals(
+            AndroidProviderRoute.PLATFORM,
+            selectAndroidProviderRoute(
+                locationProvider = LocationProvider.PLAYSERVICES,
+                googlePlayServicesAvailable = false
+            )
+        )
+    }
+
+    @Test
+    fun platformProviderAlwaysUsesPlatformRoute() {
+        assertEquals(
+            AndroidProviderRoute.PLATFORM,
+            selectAndroidProviderRoute(
+                locationProvider = LocationProvider.ANDROID_PLATFORM,
+                googlePlayServicesAvailable = true
+            )
+        )
+    }
+
+    @Test
+    fun autoAndPlayServicesFallbackToPlatformAfterFusedRequestFailure() {
+        assertEquals(
+            AndroidProviderRoute.PLATFORM,
+            selectAndroidFallbackRouteAfterFusedFailure(LocationProvider.AUTO)
+        )
+        assertEquals(
+            AndroidProviderRoute.PLATFORM,
+            selectAndroidFallbackRouteAfterFusedFailure(LocationProvider.PLAYSERVICES)
+        )
+    }
+
+    @Test
+    fun currentLastKnownAndWatchInvokePlatformFallbackAfterFusedRequestFailure() {
+        assertInvokesPlatformFallback { platformFallback, failWithoutFallback ->
+            runAndroidCurrentPositionFallbackAfterFusedFailure(
+                locationProvider = LocationProvider.AUTO,
+                runPlatformFallback = platformFallback,
+                failWithoutFallback = failWithoutFallback
+            )
+        }
+        assertInvokesPlatformFallback { platformFallback, failWithoutFallback ->
+            runAndroidLastKnownPositionFallbackAfterFusedFailure(
+                locationProvider = LocationProvider.PLAYSERVICES,
+                runPlatformFallback = platformFallback,
+                failWithoutFallback = failWithoutFallback
+            )
+        }
+        assertInvokesPlatformFallback { platformFallback, failWithoutFallback ->
+            runAndroidWatchPositionFallbackAfterFusedFailure(
+                locationProvider = LocationProvider.AUTO,
+                runPlatformFallback = platformFallback,
+                failWithoutFallback = failWithoutFallback
+            )
+        }
+    }
+
+    private fun assertInvokesPlatformFallback(
+        runFallback: (
+            runPlatformFallback: () -> Unit,
+            failWithoutFallback: () -> Unit
+        ) -> Unit
+    ) {
+        var platformFallbackCalls = 0
+        var errorCalls = 0
+
+        runFallback(
+            { platformFallbackCalls += 1 },
+            { errorCalls += 1 }
+        )
+
+        assertEquals(1, platformFallbackCalls)
+        assertEquals(0, errorCalls)
+    }
+}

package/ios/IOSBackgroundHttpSync.swift

@@ -0,0 +1,126 @@
+import Foundation
+
+final class IOSBackgroundHttpSync {
+    func uploadWithRetry(
+        locations: [StoredBackgroundLocation],
+        sync: BackgroundHttpSyncOptions
+    ) -> BackgroundHttpSyncResult {
+        if sync.batch == false {
+            return uploadSingleLocationsWithRetry(locations: locations, sync: sync)
+        }
+        let maxAttempts = sync.retry == true
+            ? Int(sync.maxRetries ?? 3) + 1
+            : 1
+        var lastResult: BackgroundHttpSyncResult?
+        for attempt in 0..<max(maxAttempts, 1) {
+            let result = upload(locations: locations, sync: sync)
+            if result.success {
+                return result
+            }
+            lastResult = result
+            if attempt < maxAttempts - 1 {
+                Thread.sleep(forTimeInterval: 1)
+            }
+        }
+        return lastResult ?? BackgroundHttpSyncResult(
+            success: false,
+            statusCode: nil,
+            syncedLocationIds: [],
+            failedLocationIds: locations.map(\.id),
+            error: "HTTP sync failed"
+        )
+    }
+
+    private func uploadSingleLocationsWithRetry(
+        locations: [StoredBackgroundLocation],
+        sync: BackgroundHttpSyncOptions
+    ) -> BackgroundHttpSyncResult {
+        let maxAttempts = sync.retry == true
+            ? Int(sync.maxRetries ?? 3) + 1
+            : 1
+        var synced: [String] = []
+        var failed: [String] = []
+        var lastStatusCode: Double?
+        var lastError: String?
+
+        for location in locations {
+            var didSync = false
+            for attempt in 0..<max(maxAttempts, 1) {
+                let result = upload(locations: [location], sync: sync)
+                lastStatusCode = result.statusCode
+                lastError = result.error
+                if result.success {
+                    synced.append(location.id)
+                    didSync = true
+                    break
+                }
+                if attempt < maxAttempts - 1 {
+                    Thread.sleep(forTimeInterval: 1)
+                }
+            }
+            if !didSync {
+                failed.append(location.id)
+            }
+        }
+
+        return BackgroundHttpSyncResult(
+            success: failed.isEmpty,
+            statusCode: lastStatusCode,
+            syncedLocationIds: synced,
+            failedLocationIds: failed,
+            error: failed.isEmpty ? nil : (lastError ?? "HTTP sync failed")
+        )
+    }
+
+    private func upload(
+        locations: [StoredBackgroundLocation],
+        sync: BackgroundHttpSyncOptions
+    ) -> BackgroundHttpSyncResult {
+        guard let url = URL(string: sync.url) else {
+            return BackgroundHttpSyncResult(
+                success: false,
+                statusCode: nil,
+                syncedLocationIds: [],
+                failedLocationIds: locations.map(\.id),
+                error: "Invalid sync URL"
+            )
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = sync.method?.stringValue ?? "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        sync.headers?.forEach { request.setValue($0.value, forHTTPHeaderField: $0.key) }
+        let body: Any
+        if sync.batch == false, let location = locations.first {
+            if var template = sync.bodyTemplate.map(bodyTemplateDictionary) {
+                template["location"] = storedLocationDictionary(location)
+                body = template
+            } else {
+                body = storedLocationDictionary(location)
+            }
+        } else {
+            var template = sync.bodyTemplate.map(bodyTemplateDictionary) ?? [:]
+            template["locations"] = locations.map(storedLocationDictionary)
+            body = template
+        }
+        request.httpBody = try? JSONSerialization.data(withJSONObject: body)
+
+        let semaphore = DispatchSemaphore(value: 0)
+        var statusCode: Int?
+        var requestError: String?
+        URLSession.shared.dataTask(with: request) { _, response, error in
+            statusCode = (response as? HTTPURLResponse)?.statusCode
+            requestError = error?.localizedDescription
+            semaphore.signal()
+        }.resume()
+        semaphore.wait()
+
+        let success = statusCode.map { (200..<300).contains($0) } ?? false
+        return BackgroundHttpSyncResult(
+            success: success,
+            statusCode: statusCode.map(Double.init),
+            syncedLocationIds: success ? locations.map(\.id) : [],
+            failedLocationIds: success ? [] : locations.map(\.id),
+            error: success ? nil : (requestError ?? "HTTP sync failed")
+        )
+    }
+}

package/ios/IOSBackgroundLocationDelegate.swift

@@ -0,0 +1,36 @@
+import CoreLocation
+import Foundation
+
+final class NitroBackgroundLocationDelegate: NSObject, CLLocationManagerDelegate {
+    weak var owner: NitroBackgroundLocation?
+
+    init(owner: NitroBackgroundLocation) {
+        self.owner = owner
+        super.init()
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        owner?.handleLocations(locations)
+        owner?.applyDeferredUpdatesIfNeeded(manager)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        owner?.handleError(error)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
+        owner?.handleRegion(region, transition: .enter)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didExitRegion region: CLRegion) {
+        owner?.handleRegion(region, transition: .exit)
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        owner?.handleAuthorizationChange()
+    }
+
+    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
+        owner?.handleAuthorizationChange()
+    }
+}

package/ios/IOSBackgroundMotion.swift

@@ -0,0 +1,55 @@
+import CoreLocation
+import CoreMotion
+import Foundation
+
+internal func motionActivityType(_ activity: CMMotionActivity) -> DetectedActivityType {
+    if activity.automotive {
+        return .invehicle
+    }
+    if activity.cycling {
+        return .onbicycle
+    }
+    if activity.running {
+        return .running
+    }
+    if activity.walking {
+        return .walking
+    }
+    if activity.stationary {
+        return .still
+    }
+    return .unknown
+}
+
+internal func motionConfidence(_ confidence: CMMotionActivityConfidence) -> Double {
+    switch confidence {
+    case .low:
+        return 25
+    case .medium:
+        return 60
+    case .high:
+        return 95
+    @unknown default:
+        return 0
+    }
+}
+
+internal func mapActivityType(_ activityType: IOSBackgroundActivityType?) -> CLActivityType {
+    switch activityType {
+    case .automotivenavigation:
+        return .automotiveNavigation
+    case .fitness:
+        return .fitness
+    case .othernavigation:
+        return .otherNavigation
+    case .airborne:
+        if #available(iOS 12.0, *) {
+            return .airborne
+        }
+        return .other
+    case .other, nil:
+        return .other
+    @unknown default:
+        return .other
+    }
+}