expo-location 58.0.8 → 58.0.10

package/CHANGELOG.md

@@ -1,14 +1,20 @@
 # Changelog
 
-## Unpublished
+## 58.0.10
 
-### 🛠 Breaking changes
+### Patch Changes
 
-### 🎉 New features
+- Bump precompiled artifacts due to ABI breakage in expo-modules-jsi@58.0.6. ([#50881](https://github.com/expo/expo/pull/50881) by [@kitten](https://github.com/kitten))
+- [Android] Add the core functionalities for the **next** version: permission getters and requesters, position getter, and `enableLocationServices` prompt. Introduce `LocationProvider` interface to allow for multiple implementations: for now `gms` and `android.location`. ([#49988](https://github.com/expo/expo/pull/49988) by [@HubertBer](https://github.com/HubertBer))
+- [Android] Add the position watchers to the **next** implementation. Update the `LocationProvider` interface to also support watchers and implement it in both GMS and Android providers. ([#49992](https://github.com/expo/expo/pull/49992) by [@HubertBer](https://github.com/HubertBer))
 
-### 🐛 Bug fixes
+## 58.0.9
 
-### 💡 Others
+### Patch Changes
+
+- Force-bump all packages, due to migration to changesets. ([#50762](https://github.com/expo/expo/pull/50762) by [@kitten](https://github.com/kitten))
+- Updated dependencies. ([#50762](https://github.com/expo/expo/pull/50762))
+  - @expo/image-utils@0.12.2
 
 ## 58.0.8 — 2026-09-28
 
@@ -609,13 +615,6 @@ _This version does not introduce any user-facing changes._
 
 - Allow location to work on Android with only coarse location permission. All apps do not require fine/precise location permission, but in past Expo was enforcing fine/precise even if you only needed coarse level location. ([#15760](https://github.com/expo/expo/pull/15760) by [@Noitidart](https://github.com/Noitidart))
 
-## Unpublished
-
-### 🛠 Breaking changes
-
-- Add an option to whether kill or keep the foreground service when app is killed on Android. ([#15633](https://github.com/expo/expo/pull/15633) by [@islamouzou](https://github.com/islamouzou))
-- Updated `@expo/config-plugins` from `4.0.2` to `4.0.14` ([#15621](https://github.com/expo/expo/pull/15621) by [@EvanBacon](https://github.com/EvanBacon))
-
 ## 14.0.2 — 2022-02-01
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -4,17 +4,18 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '58.0.8'
+version = '58.0.10'
 
 android {
   namespace "expo.modules.location"
   defaultConfig {
     versionCode 29
-    versionName "58.0.8"
+    versionName "58.0.10"
     consumerProguardFiles("proguard-rules.pro")
   }
 }
 
 dependencies {
   api 'com.google.android.gms:play-services-location:21.0.1'
+  implementation "androidx.core:core-ktx:1.17.0"
 }

package/android/src/main/java/expo/modules/location/next/Constants.kt

@@ -0,0 +1,6 @@
+package expo.modules.location.next
+
+const val POSITION_CHANGED = "positionChanged"
+
+/** A unique, arbitrary number used to recognise the result of the "enable location services" activity. */
+const val SETTINGS_REQUEST_CODE = 1492

package/android/src/main/java/expo/modules/location/next/LocationModuleNext.kt

@@ -0,0 +1,230 @@
+package expo.modules.location.next
+
+import android.content.Context
+import android.location.LocationManager
+import androidx.core.location.LocationManagerCompat
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.location.LocationServices
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.sharedobjects.SharedRef
+import expo.modules.location.next.locationProviders.AndroidLocationProvider
+import expo.modules.location.next.locationProviders.EnableLocationServicesResult
+import expo.modules.location.next.locationProviders.FallbackLocationProvider
+import expo.modules.location.next.locationProviders.GmsLocationProvider
+import expo.modules.location.next.locationProviders.LocationProvider
+import kotlinx.coroutines.CompletableDeferred
+import expo.modules.location.next.locationProviders.WatchPositionParameters
+import expo.modules.location.next.locationProviders.PositionUpdatesSession
+import java.lang.ref.WeakReference
+import kotlin.time.Duration
+
+class LocationModuleNext : Module() {
+  private val context: Context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+  private val permissionsManager: Permissions
+    get() = appContext.permissions ?: throw NoPermissionsModuleException()
+
+  val watchSessions: MutableList<WeakReference<PausableWatchSession>> = mutableListOf()
+  val fusedLocationProviderInstance: SharedRef<LocationProvider> by lazy {
+    val fusedLocationProvider = LocationServices.getFusedLocationProviderClient(context)
+
+    val gmsLocationProvider = GmsLocationProvider(
+      fusedLocationProvider,
+      LocationServices.getSettingsClient(context)
+    ) { GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context) == ConnectionResult.SUCCESS }
+
+    SharedRef(gmsLocationProvider)
+  }
+
+  val androidLocationProviderInstance: SharedRef<LocationProvider> by lazy {
+    SharedRef(AndroidLocationProvider(context))
+  }
+
+  lateinit var currentLocationProvider: LocationProvider
+
+  lateinit var locationManager: LocationManager
+
+  @Volatile
+  private var locationServicesPrompt: CompletableDeferred<Boolean>? = null
+
+  fun createPositionWatchHandle(initialParameters: WatchPositionParameters, session: PositionUpdatesSession): PositionWatchHandle = synchronized(watchSessions) {
+    val pausableSession = PausableWatchSession(initialParameters, session)
+    watchSessions.add(WeakReference(pausableSession))
+    return@synchronized PositionWatchHandle(pausableSession)
+  }
+
+  override fun definition() = ModuleDefinition {
+    Name("LocationModuleNext")
+
+    OnCreate {
+      currentLocationProvider = FallbackLocationProvider(
+        listOf(fusedLocationProviderInstance.ref, androidLocationProviderInstance.ref)
+      )
+      locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+    }
+
+    // Permissions
+    AsyncFunction("requestForegroundPermissions") Coroutine { options: RequestForegroundPermissionsOptions? ->
+      permissionsManager.requestForegroundPermissions(options)
+      return@Coroutine permissionsManager.getLocationPermissions(background = false)
+    }
+
+    AsyncFunction("getForegroundPermissions") Coroutine { ->
+      return@Coroutine permissionsManager.getLocationPermissions(background = false)
+    }
+
+    AsyncFunction("requestBackgroundPermissions") Coroutine { ->
+      permissionsManager.requestBackgroundPermissions()
+      return@Coroutine permissionsManager.getLocationPermissions(background = true)
+    }
+
+    AsyncFunction("getBackgroundPermissions") Coroutine { ->
+      return@Coroutine permissionsManager.getLocationPermissions(background = true)
+    }
+
+    // Location providers
+    Function("setLocationProvider") { locationProvider: SharedRef<LocationProvider> ->
+      currentLocationProvider = locationProvider.ref
+    }
+
+    Function("getSelectedLocationProviderName") {
+      currentLocationProvider.name
+    }
+
+    Class("LocationProvider") {
+      StaticFunction("Gms") { ->
+        fusedLocationProviderInstance
+      }
+      StaticFunction("Android") { ->
+        androidLocationProviderInstance
+      }
+      StaticFunction("Fallback") { providers: List<SharedRef<LocationProvider>> ->
+        SharedRef(FallbackLocationProvider(providers.map { it.ref }))
+      }
+    }
+
+    AsyncFunction("getPosition") Coroutine { options: GetPositionOptions? ->
+      permissionsManager.ensureForegroundPermissions()
+      val providerOptions = (options ?: GetPositionOptions()).toProviderOptions()
+      return@Coroutine currentLocationProvider.getPosition(providerOptions).getOrNull("getPosition")
+    }
+
+    Function("watchPosition") { profile: LocationProfile? ->
+      permissionsManager.ensureForegroundPermissions()
+      val parameters = (profile ?: LocationProfile.DEFAULT).watchParameters()
+      return@Function createPositionWatchHandle(parameters, currentLocationProvider.watchPosition().getOrThrow("watchPosition"))
+    }
+
+    Function("hasLocationServicesEnabled") { ->
+      hasLocationServicesEnabled()
+    }
+
+    AsyncFunction("enableLocationServices") Coroutine { ->
+      if (hasLocationServicesEnabled()) {
+        return@Coroutine true
+      }
+      locationServicesPrompt?.let {
+        return@Coroutine it.await()
+      }
+
+      val promptResult = CompletableDeferred<Boolean>()
+      locationServicesPrompt = promptResult
+      try {
+        val enableServicesResult = currentLocationProvider
+          .enableLocationServices(appContext.throwingActivity)
+          .getOrThrow("enableLocationServices")
+
+        when (enableServicesResult) {
+          is EnableLocationServicesResult.Disabled -> promptResult.complete(false)
+          is EnableLocationServicesResult.Enabled -> promptResult.complete(true)
+          is EnableLocationServicesResult.ResolutionPending -> {}
+        }
+
+        return@Coroutine promptResult.await()
+      } catch (cause: Throwable) {
+        promptResult.completeExceptionally(cause)
+        throw cause
+      } finally {
+        locationServicesPrompt = null
+      }
+    }
+
+    OnActivityResult { _, payload ->
+      if (payload.requestCode == SETTINGS_REQUEST_CODE) {
+        locationServicesPrompt?.complete(hasLocationServicesEnabled())
+      }
+    }
+
+    Class(PositionWatchHandle::class) {
+      Constructor {
+        throw PositionWatchHandleCreationException()
+      }
+
+      Events(POSITION_CHANGED)
+
+      Function("pause") { locationWatchHandle: PositionWatchHandle ->
+        locationWatchHandle.session.pause()
+      }
+
+      Function("resume") { locationWatchHandle: PositionWatchHandle ->
+        return@Function locationWatchHandle.session.resume()
+      }
+
+      Function("withProfile") { locationWatchHandle: PositionWatchHandle, profile: LocationProfile ->
+        locationWatchHandle.session.withProfile(profile)
+        locationWatchHandle
+      }
+
+      Function("withInterval") { locationWatchHandle: PositionWatchHandle, interval: Duration ->
+        if (interval < Duration.ZERO || interval == Duration.INFINITE) {
+          throw InvalidWatchIntervalException(interval)
+        }
+        locationWatchHandle.session.withInterval(interval)
+        locationWatchHandle
+      }
+
+      Function("restart") { locationWatchHandle: PositionWatchHandle ->
+        return@Function locationWatchHandle.session.restart()
+      }
+
+      Function("status") { locationWatchHandle: PositionWatchHandle ->
+        locationWatchHandle.session.status()
+      }
+    }
+
+    OnDestroy {
+      synchronized(watchSessions) {
+        for (session in watchSessions) {
+          session.get()?.release()
+        }
+      }
+    }
+
+    OnActivityEntersForeground {
+      synchronized(watchSessions) {
+        for (session in watchSessions) {
+          session.get()?.onLifecycleChange(true)
+        }
+      }
+    }
+
+    OnActivityEntersBackground {
+      synchronized(watchSessions) {
+        watchSessions.removeIf { it.get() == null }
+        for (session in watchSessions) {
+          session.get()?.onLifecycleChange(false)
+        }
+      }
+    }
+  }
+
+  private fun hasLocationServicesEnabled(): Boolean {
+    return LocationManagerCompat.isLocationEnabled(locationManager)
+  }
+}

package/android/src/main/java/expo/modules/location/next/LocationPermissions.kt

@@ -0,0 +1,157 @@
+package expo.modules.location.next
+
+import android.Manifest
+import android.os.Build
+import androidx.annotation.ChecksSdkIntAtLeast
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.interfaces.permissions.PermissionsResponse
+import expo.modules.interfaces.permissions.PermissionsStatus
+import kotlinx.coroutines.CompletableDeferred
+
+class NoPermissionsModuleException :
+  CodedException("Permissions module is null. Are you sure all the installed Expo modules are properly linked?")
+
+class NoPermissionInManifestException(permissionName: String) :
+  CodedException("You need to add `$permissionName` to the AndroidManifest")
+
+class ForegroundLocationPermissionsNotGrantedException :
+  CodedException("Foreground location permissions are not granted. Call requestForegroundPermissions() and make sure the user grants precise or approximate location.")
+
+class BackgroundLocationPermissionsNotGrantedException :
+  CodedException("Background location permissions are not granted. Call requestBackgroundPermissions() after foreground location has been granted.")
+
+class RequestingBackgroundPermissionsWithoutForegroundGrantException :
+  CodedException("Need to have foreground permissions granted, before asking for background permissions. Call requestForegroundPermissions() first and make sure the foreground location is granted.")
+
+private val FOREGROUND_PERMISSIONS = arrayOf(
+  Manifest.permission.ACCESS_COARSE_LOCATION,
+  Manifest.permission.ACCESS_FINE_LOCATION
+)
+
+private val LOCATION_PERMISSIONS = arrayOf(
+  Manifest.permission.ACCESS_COARSE_LOCATION,
+  Manifest.permission.ACCESS_FINE_LOCATION,
+  Manifest.permission.ACCESS_BACKGROUND_LOCATION
+)
+
+private val COARSE_PERMISSIONS = arrayOf(Manifest.permission.ACCESS_COARSE_LOCATION)
+
+// Before Q there is no separate background permission -- foreground access covers it.
+// ChecksSdkIntAtLeast keeps lint's API-level narrowing working through the call.
+@ChecksSdkIntAtLeast(api = Build.VERSION_CODES.Q)
+private fun supportsBackgroundPermission(): Boolean = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+
+internal suspend fun Permissions.requestBackgroundPermissions() {
+  if (!supportsBackgroundPermission()) {
+    return
+  }
+
+  if (!isPermissionPresentInManifest(Manifest.permission.ACCESS_BACKGROUND_LOCATION)) {
+    throw NoPermissionInManifestException("ACCESS_BACKGROUND_LOCATION")
+  }
+
+  val foregroundPermission = queryPermissions(*FOREGROUND_PERMISSIONS).foregroundPermission()
+  if (foregroundPermission.status != PermissionsStatus.GRANTED) {
+    throw RequestingBackgroundPermissionsWithoutForegroundGrantException()
+  }
+
+  requestPermissions(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+}
+
+internal suspend fun Permissions.requestForegroundPermissions(options: RequestForegroundPermissionsOptions?) {
+  val permissions = when (options?.accuracy ?: LocationAccuracyOption.FULL) {
+    LocationAccuracyOption.FULL -> FOREGROUND_PERMISSIONS
+    LocationAccuracyOption.REDUCED -> COARSE_PERMISSIONS
+  }
+  requestPermissions(*permissions)
+}
+
+internal suspend fun Permissions.getLocationPermissions(background: Boolean): LocationPermissionResponse {
+  val permissions = if (supportsBackgroundPermission()) {
+    LOCATION_PERMISSIONS
+  } else {
+    FOREGROUND_PERMISSIONS
+  }
+  val queried = queryPermissions(*permissions)
+
+  val foregroundPermission = queried.foregroundPermission()
+  val backgroundPermission = if (supportsBackgroundPermission()) {
+    queried.backgroundPermission()
+  } else {
+    foregroundPermission
+  }
+  val foregroundGranted = foregroundPermission.status == PermissionsStatus.GRANTED
+  val backgroundGranted = backgroundPermission.status == PermissionsStatus.GRANTED
+  val wantedPermission = if (background) {
+    backgroundPermission
+  } else {
+    foregroundPermission
+  }
+
+  return LocationPermissionResponse(
+    status = LocationPermissionStatus.fromString(wantedPermission.status.status),
+    granted = foregroundGranted && (!background || backgroundGranted),
+    canAskAgain = wantedPermission.canAskAgain,
+    scope = when {
+      backgroundGranted -> LocationScope.ALWAYS
+      foregroundGranted -> LocationScope.WHEN_IN_USE
+      else -> LocationScope.NOT_GRANTED
+    },
+    accuracy = queried.locationAccuracy(),
+    expires = "never"
+  )
+}
+
+internal fun Permissions.ensureForegroundPermissions() {
+  val hasFine = hasGrantedPermissions(Manifest.permission.ACCESS_FINE_LOCATION)
+  val hasCoarse = hasGrantedPermissions(Manifest.permission.ACCESS_COARSE_LOCATION)
+  if (!hasFine && !hasCoarse) {
+    throw ForegroundLocationPermissionsNotGrantedException()
+  }
+}
+
+internal fun Permissions.ensureBackgroundPermissions() {
+  ensureForegroundPermissions()
+  if (!supportsBackgroundPermission()) {
+    return
+  }
+  if (!hasGrantedPermissions(Manifest.permission.ACCESS_BACKGROUND_LOCATION)) {
+    throw BackgroundLocationPermissionsNotGrantedException()
+  }
+}
+
+private suspend fun Permissions.queryPermissions(vararg permissions: String): Map<String, PermissionsResponse> {
+  val result = CompletableDeferred<Map<String, PermissionsResponse>>()
+  getPermissions({ result.complete(it) }, *permissions)
+  return result.await()
+}
+
+private suspend fun Permissions.requestPermissions(vararg permissions: String): Map<String, PermissionsResponse> {
+  val result = CompletableDeferred<Map<String, PermissionsResponse>>()
+  askForPermissions({ result.complete(it) }, *permissions)
+  return result.await()
+}
+
+private fun Map<String, PermissionsResponse>.responseFor(permission: String): PermissionsResponse =
+  this[permission] ?: PermissionsResponse(PermissionsStatus.UNDETERMINED)
+
+private fun Map<String, PermissionsResponse>.foregroundPermission(): PermissionsResponse {
+  val coarse = responseFor(Manifest.permission.ACCESS_COARSE_LOCATION)
+  val fine = responseFor(Manifest.permission.ACCESS_FINE_LOCATION)
+  val status = when {
+    coarse.status == PermissionsStatus.GRANTED || fine.status == PermissionsStatus.GRANTED -> PermissionsStatus.GRANTED
+    coarse.status == PermissionsStatus.DENIED || fine.status == PermissionsStatus.DENIED -> PermissionsStatus.DENIED
+    else -> PermissionsStatus.UNDETERMINED
+  }
+  return PermissionsResponse(status, coarse.canAskAgain || fine.canAskAgain)
+}
+
+private fun Map<String, PermissionsResponse>.backgroundPermission(): PermissionsResponse =
+  responseFor(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+
+private fun Map<String, PermissionsResponse>.locationAccuracy(): LocationAccuracy = when {
+  responseFor(Manifest.permission.ACCESS_FINE_LOCATION).status == PermissionsStatus.GRANTED -> LocationAccuracy.FULL
+  responseFor(Manifest.permission.ACCESS_COARSE_LOCATION).status == PermissionsStatus.GRANTED -> LocationAccuracy.REDUCED
+  else -> LocationAccuracy.NOT_GRANTED
+}

package/android/src/main/java/expo/modules/location/next/LocationRecords.kt

@@ -0,0 +1,201 @@
+package expo.modules.location.next
+
+import android.location.Location
+import android.os.Build
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.Enumerable
+import expo.modules.kotlin.types.OptimizedRecord
+import expo.modules.location.next.locationProviders.GetCurrentPositionOptions
+import expo.modules.location.next.locationProviders.LocationPriority
+import expo.modules.location.next.locationProviders.WatchPositionParameters
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+enum class LocationPermissionStatus(val value: String) : Enumerable {
+  GRANTED("granted"),
+  DENIED("denied"),
+  UNDETERMINED("undetermined");
+
+  companion object {
+    fun fromString(status: String?): LocationPermissionStatus = when (status) {
+      "granted" -> GRANTED
+      "denied" -> DENIED
+      else -> UNDETERMINED
+    }
+  }
+}
+
+enum class LocationScope(val value: String) : Enumerable {
+  ALWAYS("always"),
+  WHEN_IN_USE("whenInUse"),
+  NOT_GRANTED("notGranted")
+}
+
+enum class LocationAccuracy(val value: String) : Enumerable {
+  FULL("full"),
+  REDUCED("reduced"),
+  NOT_GRANTED("notGranted")
+}
+
+enum class LocationAccuracyOption(val value: String) : Enumerable {
+  FULL("full"),
+  REDUCED("reduced")
+}
+
+class RequestForegroundPermissionsOptions(
+  @Field val accuracy: LocationAccuracyOption? = null
+) : Record
+
+class LocationPermissionResponse(
+  @Field val status: LocationPermissionStatus,
+  @Field val granted: Boolean,
+  @Field val canAskAgain: Boolean,
+  @Field val scope: LocationScope,
+  @Field val accuracy: LocationAccuracy,
+  @Field val expires: String = "never"
+) : Record
+
+enum class LocationProfile(val value: String) : Enumerable {
+  DEFAULT("default"),
+  AUTOMOTIVE_NAVIGATION("automotiveNavigation"),
+  OTHER_NAVIGATION("otherNavigation"),
+  FITNESS("fitness"),
+  AIRBORNE("airborne"),
+  LOW_POWER("lowPower");
+
+  fun priority(): LocationPriority {
+    return when (this) {
+      DEFAULT -> LocationPriority.BALANCED_POWER_ACCURACY
+      AUTOMOTIVE_NAVIGATION -> LocationPriority.HIGH_ACCURACY
+      OTHER_NAVIGATION -> LocationPriority.HIGH_ACCURACY
+      FITNESS -> LocationPriority.HIGH_ACCURACY
+      AIRBORNE -> LocationPriority.HIGH_ACCURACY
+      LOW_POWER -> LocationPriority.LOW_POWER
+    }
+  }
+
+  fun watchParameters(): WatchPositionParameters {
+    return when (this) {
+      DEFAULT -> WatchPositionParameters(LocationPriority.BALANCED_POWER_ACCURACY, 5.seconds, Duration.ZERO)
+      AUTOMOTIVE_NAVIGATION -> WatchPositionParameters(LocationPriority.HIGH_ACCURACY, 1.seconds, Duration.ZERO)
+      OTHER_NAVIGATION -> WatchPositionParameters(LocationPriority.HIGH_ACCURACY, 2.seconds, Duration.ZERO)
+      FITNESS -> WatchPositionParameters(LocationPriority.HIGH_ACCURACY, 2.seconds, Duration.ZERO)
+      AIRBORNE -> WatchPositionParameters(LocationPriority.HIGH_ACCURACY, 1.seconds, Duration.ZERO)
+      LOW_POWER -> WatchPositionParameters(LocationPriority.LOW_POWER, 60.seconds, 300.seconds)
+    }
+  }
+}
+
+class GetPositionOptions(
+  @Field val maxCachedAge: Double? = null,
+  @Field val timeout: Double? = null,
+  @Field val profile: LocationProfile = LocationProfile.DEFAULT
+) : Record {
+  fun toProviderOptions() = GetCurrentPositionOptions(
+    maxCachedAge = (maxCachedAge ?: 0.0).seconds,
+    timeout = (timeout ?: 30.0).seconds,
+    priority = profile.priority()
+  )
+}
+
+@OptimizedRecord
+class Coordinates(
+  @Field val latitude: Double,
+  @Field val longitude: Double
+) : Record
+
+@OptimizedRecord
+class Position(
+  @Field val coordinates: Coordinates,
+  @Field val timestamp: Double,
+  @Field val mocked: Boolean,
+
+  @Field val mslAltitude: Double? = null,
+  @Field val altitude: Double? = null,
+  @Field val speed: Double? = null,
+  @Field val heading: Double? = null,
+
+  @Field val horizontalAccuracy: Double? = null,
+  @Field val verticalAccuracy: Double? = null,
+  @Field val speedAccuracy: Double? = null,
+  @Field val headingAccuracy: Double? = null
+) : Record
+
+fun Location.mslAltitude(): Double? {
+  return if (Build.VERSION.SDK_INT >= 34 && hasMslAltitude()) {
+    mslAltitudeMeters
+  } else {
+    null
+  }
+}
+
+fun Location.verticalAccuracy(): Double? {
+  return if (Build.VERSION.SDK_INT >= 26 && hasAltitude() && hasVerticalAccuracy()) {
+    verticalAccuracyMeters.toDouble()
+  } else {
+    null
+  }
+}
+
+fun Location.speedAccuracy(): Double? {
+  return if (Build.VERSION.SDK_INT >= 26 && hasSpeed() && hasSpeedAccuracy()) {
+    speedAccuracyMetersPerSecond.toDouble()
+  } else {
+    null
+  }
+}
+
+fun Location.headingAccuracy(): Double? {
+  return if (Build.VERSION.SDK_INT >= 26 && hasBearing() && hasBearingAccuracy()) {
+    bearingAccuracyDegrees.toDouble()
+  } else {
+    null
+  }
+}
+
+fun Location.mocked(): Boolean {
+  return if (Build.VERSION.SDK_INT >= 31) {
+    isMock
+  } else {
+    @Suppress("DEPRECATION")
+    isFromMockProvider
+  }
+}
+
+fun Location.toPosition(): Position {
+  return Position(
+    coordinates = Coordinates(
+      latitude,
+      longitude
+    ),
+    timestamp = time.toDouble(),
+    mocked = mocked(),
+
+    mslAltitude = mslAltitude(),
+    altitude = if (hasAltitude()) {
+      altitude
+    } else {
+      null
+    },
+    speed = if (hasSpeed()) {
+      speed.toDouble()
+    } else {
+      null
+    },
+    heading = if (hasBearing()) {
+      bearing.toDouble()
+    } else {
+      null
+    },
+
+    horizontalAccuracy = if (this.hasAccuracy()) {
+      this.accuracy.toDouble()
+    } else {
+      null
+    },
+    verticalAccuracy = verticalAccuracy(),
+    speedAccuracy = speedAccuracy(),
+    headingAccuracy = headingAccuracy()
+  )
+}