Simplify GPS logic

Author: kylecorry31

app/src/main/java/com/kylecorry/trailsensecore/infrastructure/sensors/gps/GPS.kt

@@ -9,9 +9,13 @@ import com.kylecorry.trailsensecore.domain.Accuracy
 import com.kylecorry.trailsensecore.domain.geo.Coordinate
 import com.kylecorry.trailsensecore.infrastructure.sensors.AbstractSensor
 import com.kylecorry.trailsensecore.infrastructure.sensors.SensorChecker
+import com.kylecorry.trailsensecore.infrastructure.system.PermissionUtils
+import java.time.Duration
 import java.time.Instant
 
-class GPS(context: Context) : AbstractSensor(), IGPS {
+
+@SuppressLint("MissingPermission")
+class GPS(private val context: Context) : AbstractSensor(), IGPS {
 
     override val hasValidReading: Boolean
         get() = hadRecentValidReading()
@@ -34,14 +38,14 @@ class GPS(context: Context) : AbstractSensor(), IGPS {
     override val speed: Float
         get() = _speed
 
-    override val altitude: Float
-        get() = _altitude
-
     override val time: Instant
         get() = _time
 
-    private val locationManager = context.getSystemService<LocationManager>()
-    private val sensorChecker = SensorChecker(context)
+    override val altitude: Float
+        get() = _altitude
+
+    private val locationManager by lazy { context.getSystemService<LocationManager>() }
+    private val sensorChecker by lazy { SensorChecker(context) }
     private val locationListener = SimpleLocationListener { updateLastLocation(it, true) }
 
     private var _altitude = 0f
@@ -54,19 +58,25 @@ class GPS(context: Context) : AbstractSensor(), IGPS {
     private var _location = Coordinate.zero
 
     private var lastLocation: Location? = null
-    private var lastUpdate = 0L
 
-    private var fixStart: Long = 0L
-    private val maxFixTime = 8000L
+    init {
+        try {
+            if (PermissionUtils.isLocationEnabled(context)) {
+                updateLastLocation(
+                    locationManager?.getLastKnownLocation(LocationManager.GPS_PROVIDER),
+                    false
+                )
+            }
+        } catch (e: Exception) {
+            // Do nothing
+        }
+    }
 
-    @SuppressLint("MissingPermission")
     override fun startImpl() {
         if (!sensorChecker.hasGPS()) {
             return
         }
 
-        fixStart = System.currentTimeMillis()
-
         if (lastLocation == null) {
             updateLastLocation(
                 locationManager?.getLastKnownLocation(LocationManager.GPS_PROVIDER),
@@ -91,104 +101,47 @@ class GPS(context: Context) : AbstractSensor(), IGPS {
             return
         }
 
+        _location = Coordinate(location.latitude, location.longitude)
         _time = Instant.ofEpochMilli(location.time)
-
-        val satellites = location.extras.getInt("satellites")
-        val dt = System.currentTimeMillis() - fixStart
-
-        if (useNewLocation(lastLocation, location) &&
-            location.hasAltitude() && location.altitude != 0.0
-        ) {
-            // Forces an altitude update irrespective of the satellite count - helps when the GPS is being polled in the background
-            _altitude = location.altitude.toFloat()
-        }
-
-        if (satellites < 4 && dt < maxFixTime) {
-            return
-        }
-
-        if (!useNewLocation(lastLocation, location)) {
-            if (notify) notifyListeners()
-            return
-        }
-
-        fixStart = System.currentTimeMillis()
-        lastUpdate = fixStart
-        _satellites = satellites
-        lastLocation = location
-
-        if (location.hasAccuracy()) {
-            this._accuracy = when {
-                location.accuracy < 8 -> Accuracy.High
-                location.accuracy < 16 -> Accuracy.Medium
-                else -> Accuracy.Low
-            }
-            this._horizontalAccuracy = location.accuracy
+        _satellites =
+            if (location.extras?.containsKey("satellites") == true) location.extras.getInt("satellites") else 0
+        _altitude = if (location.hasAltitude()) location.altitude.toFloat() else 0f
+        val accuracy = if (location.hasAccuracy()) location.accuracy else null
+        _accuracy = when {
+            accuracy != null && accuracy < 8 -> Accuracy.High
+            accuracy != null && accuracy < 16 -> Accuracy.Medium
+            accuracy != null -> Accuracy.Low
+            else -> Accuracy.Unknown
         }
-
-        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
-            if (location.hasVerticalAccuracy()) {
-                this._verticalAccuracy = location.verticalAccuracyMeters
+        _horizontalAccuracy = accuracy ?: 0f
+        _verticalAccuracy =
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O && location.hasVerticalAccuracy()) {
+                location.verticalAccuracyMeters
+            } else {
+                null
             }
-        }
-
-        if (location.hasSpeed()) {
-            _speed =
-                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O && location.hasSpeedAccuracy()) {
-                    if (location.speed < location.speedAccuracyMetersPerSecond * 0.68) {
-                        0f
-                    } else {
-                        location.speed
-                    }
-
+        // TODO: Add speed accuracy to IGPS
+        _speed = if (location.hasSpeed()) {
+            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O && location.hasSpeedAccuracy()) {
+                if (location.speed < location.speedAccuracyMetersPerSecond * 0.68) {
+                    0f
                 } else {
                     location.speed
                 }
-        }
-
-        this._location = Coordinate(
-            location.latitude,
-            location.longitude
-        )
-
-        if (location.hasAltitude() && location.altitude != 0.0) {
-            _altitude = location.altitude.toFloat()
+            } else {
+                location.speed
+            }
+        } else {
+            0f
         }
 
         if (notify) notifyListeners()
     }
 
     private fun hadRecentValidReading(): Boolean {
-        val now = System.currentTimeMillis()
-        val recentThreshold = 1000 * 60 * 2L
-        return now - lastUpdate <= recentThreshold
-    }
-
-    private fun useNewLocation(current: Location?, newLocation: Location): Boolean {
-        // Modified from https://stackoverflow.com/questions/10588982/retrieving-of-satellites-used-in-gps-fix-from-android
-        if (current == null) {
-            return true
-        }
-
-        val timeDelta = newLocation.time - current.time
-        val isSignificantlyNewer: Boolean = timeDelta > 1000 * 60 * 2
-        val isSignificantlyOlder: Boolean = timeDelta < -1000 * 60 * 2
-        val isNewer = timeDelta > 0
-
-        if (isSignificantlyNewer) {
-            return true
-        } else if (isSignificantlyOlder) {
-            return false
-        }
-
-        val accuracyDelta = (newLocation.accuracy - current.accuracy).toInt()
-        val isMoreAccurate = accuracyDelta < 0
-        val isSignificantlyLessAccurate = accuracyDelta > 30
-
-        if (isMoreAccurate) {
-            return true
-        }
-
-        return isNewer && !isSignificantlyLessAccurate
+        val last = time
+        val now = Instant.now()
+        val recentThreshold = Duration.ofMinutes(2)
+        return Duration.between(last, now) <= recentThreshold && location != Coordinate.zero
     }
 }