expo-location 16.4.0 → 16.5.1

package/CHANGELOG.md

@@ -10,6 +10,26 @@
 
 ### 💡 Others
 
+## 16.5.1 — 2023-12-19
+
+_This version does not introduce any user-facing changes._
+
+## 16.5.0 — 2023-11-14
+
+### 🛠 Breaking changes
+
+- Bumped iOS deployment target to 13.4. ([#25063](https://github.com/expo/expo/pull/25063) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+- On `Android` bump `compileSdkVersion` and `targetSdkVersion` to `34`. ([#24708](https://github.com/expo/expo/pull/24708) by [@alanjhughes](https://github.com/alanjhughes))
+
+### 💡 Others
+
+- [Android] Moved to the new Modules API. ([#24737](https://github.com/expo/expo/pull/24737) by [@behenate](https://github.com/behenate))
+- Remove `unimodule.json` in favour of `expo-module.config.json`. ([#25100](https://github.com/expo/expo/pull/25100) by [@reichhartd](https://github.com/reichhartd))
+
+### 📚 3rd party library updates
+
+- Updated `com.google.android.gms:play-services-location` to `21.0.1`. ([#25028](https://github.com/expo/expo/pull/25028) by [@behenate](https://github.com/behenate))
+
 ## 16.4.0 — 2023-10-17
 
 ### 🛠 Breaking changes

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '16.4.0'
+version = '16.5.1'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -61,11 +61,11 @@ if (!safeExtGet("expoProvidesDefaultConfig", false)) {
 android {
   // Remove this if and it's contents, when support for SDK49 is dropped
   if (!safeExtGet("expoProvidesDefaultConfig", false)) {
-    compileSdkVersion safeExtGet("compileSdkVersion", 33)
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
 
     defaultConfig {
       minSdkVersion safeExtGet("minSdkVersion", 23)
-      targetSdkVersion safeExtGet("targetSdkVersion", 33)
+      targetSdkVersion safeExtGet("targetSdkVersion", 34)
     }
 
     publishing {
@@ -94,7 +94,7 @@ android {
   namespace "expo.modules.location"
   defaultConfig {
     versionCode 29
-    versionName "16.4.0"
+    versionName "16.5.1"
   }
 }
 
@@ -105,8 +105,7 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
   }
 
-  api 'com.google.android.gms:play-services-location:20.0.0'
-
+  api 'com.google.android.gms:play-services-location:21.0.1'
   api('io.nlopez.smartlocation:library:3.3.3') {
     transitive = false
   }

package/android/src/main/AndroidManifest.xml

@@ -2,6 +2,7 @@
   <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
 
   <application>
     <service

package/android/src/main/java/expo/modules/location/LocationActivityResultListener.kt

@@ -0,0 +1,5 @@
+package expo.modules.location
+
+interface LocationActivityResultListener {
+  fun onResult(resultCode: Int)
+}

package/android/src/main/java/expo/modules/location/LocationExceptions.kt

@@ -0,0 +1,57 @@
+package expo.modules.location
+
+import expo.modules.kotlin.exception.CodedException
+
+internal class NoPermissionsModuleException :
+  CodedException("Permissions module is null. Are you sure all the installed Expo modules are properly linked?")
+
+internal class NoPermissionInManifestException(permissionName: String) :
+  CodedException("You need to add `$permissionName` to the AndroidManifest")
+
+internal class LocationBackgroundUnauthorizedException :
+  CodedException("Not authorized to use background location services")
+
+internal class LocationRequestRejectedException(cause: Exception) :
+  CodedException("Location request has been rejected: " + cause.message)
+
+internal class LocationRequestCancelledException :
+  CodedException("Location request has been cancelled")
+
+internal class LocationSettingsUnsatisfiedException :
+  CodedException("Location request failed due to unsatisfied device settings")
+
+internal class LocationUnauthorizedException :
+  CodedException("Not authorized to use location services")
+
+internal class LocationUnavailableException :
+  CodedException("Location is unavailable. Make sure that location services are enabled")
+
+internal class LocationUnknownException :
+  CodedException("Current location is unknown")
+
+internal class SensorManagerUnavailable :
+  CodedException("Sensor manager is unavailable")
+
+internal class GeocodeException(message: String?, cause: Throwable? = null) :
+  CodedException("An exception occurred when accessing the geocode: ${message ?: ""} ${cause?.message ?: ""}")
+
+internal class NoGeocodeException :
+  CodedException("Could not find the Geocoder")
+
+internal class TaskManagerNotFoundException :
+  CodedException("Could not find the task manager")
+
+internal class GeofencingException(message: String?, cause: Throwable? = null) :
+  CodedException("A geofencing exception has occurred: ${message ?: ""} ${cause?.message ?: ""}")
+
+internal class MissingActivityManagerException :
+  CodedException("Activity manager is unavailable")
+
+internal class MissingUIManagerException :
+  CodedException("UIManager is unavailable")
+
+internal class ConversionException(fromClass: Class<*>, toClass: Class<*>, message: String? = "") :
+  CodedException("Couldn't cast from ${fromClass::class.simpleName} to ${toClass::class.java.simpleName}: $message")
+
+internal class ForegroundServiceStartNotAllowedException :
+  CodedException("Couldn't start the foreground service. Foreground service cannot be started when the application is in the background.")

package/android/src/main/java/expo/modules/location/LocationHelpers.kt

@@ -0,0 +1,220 @@
+package expo.modules.location
+
+import android.content.Context
+import android.location.Location
+import android.location.LocationManager
+import android.os.Bundle
+import com.google.android.gms.location.CurrentLocationRequest
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.Granularity
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.Priority
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.location.records.LocationLastKnownOptions
+import expo.modules.location.records.LocationOptions
+import expo.modules.location.records.LocationResponse
+import expo.modules.location.records.PermissionRequestResponse
+import io.nlopez.smartlocation.location.config.LocationAccuracy
+import io.nlopez.smartlocation.location.config.LocationParams
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+
+class LocationHelpers {
+  companion object {
+    /**
+     * Checks whether given location didn't exceed given `maxAge` and fits in the required accuracy.
+     */
+    internal fun isLocationValid(location: Location?, options: LocationLastKnownOptions): Boolean {
+      if (location == null) {
+        return false
+      }
+      val maxAge = options.maxAge ?: Double.MAX_VALUE
+      val requiredAccuracy = options.requiredAccuracy ?: Double.MAX_VALUE
+      val timeDiff = (System.currentTimeMillis() - location.time).toDouble()
+      return timeDiff <= maxAge && location.accuracy <= requiredAccuracy
+    }
+
+    fun hasNetworkProviderEnabled(context: Context?): Boolean {
+      if (context == null) {
+        return false
+      }
+      val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+      return locationManager != null && locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
+    }
+
+    internal fun prepareLocationRequest(options: LocationOptions): LocationRequest {
+      val locationParams = mapOptionsToLocationParams(options)
+
+      return LocationRequest.Builder(locationParams.interval)
+        .setMinUpdateIntervalMillis(locationParams.interval)
+        .setMaxUpdateDelayMillis(locationParams.interval)
+        .setMinUpdateDistanceMeters(locationParams.distance)
+        .setPriority(mapAccuracyToPriority(options.accuracy))
+        .build()
+    }
+
+    internal fun prepareCurrentLocationRequest(options: LocationOptions): CurrentLocationRequest {
+      val locationParams = mapOptionsToLocationParams(options)
+
+      return CurrentLocationRequest.Builder().apply {
+        setGranularity(Granularity.GRANULARITY_PERMISSION_LEVEL)
+        setPriority(mapAccuracyToPriority(options.accuracy))
+        setMaxUpdateAgeMillis(locationParams.interval)
+      }.build()
+    }
+
+    fun requestSingleLocation(locationProvider: FusedLocationProviderClient, locationRequest: CurrentLocationRequest, promise: Promise) {
+      try {
+        locationProvider.getCurrentLocation(locationRequest, null)
+          .addOnSuccessListener {
+            promise.resolve(LocationResponse(it))
+          }
+          .addOnFailureListener {
+            promise.reject(LocationRequestRejectedException(it))
+          }
+          .addOnCanceledListener {
+            promise.reject(LocationRequestCancelledException())
+          }
+      } catch (e: SecurityException) {
+        promise.reject(LocationRequestRejectedException(e))
+      }
+    }
+
+    fun requestContinuousUpdates(locationModule: LocationModule, locationRequest: LocationRequest, watchId: Int, promise: Promise) {
+      locationModule.requestLocationUpdates(
+        locationRequest,
+        watchId,
+        object : LocationRequestCallbacks {
+          override fun onLocationChanged(location: Location) {
+            locationModule.sendLocationResponse(watchId, LocationResponse(location))
+          }
+
+          override fun onRequestSuccess() {
+            promise.resolve(null)
+          }
+
+          override fun onRequestFailed(cause: CodedException) {
+            promise.reject(cause)
+          }
+        }
+      )
+    }
+
+    private fun mapOptionsToLocationParams(options: LocationOptions): LocationParams {
+      val accuracy = options.accuracy
+      val locationParamsBuilder = buildLocationParamsForAccuracy(accuracy)
+
+      options.timeInterval?.let {
+        locationParamsBuilder.setInterval(it)
+      }
+      options.distanceInterval?.let {
+        locationParamsBuilder.setDistance(it.toFloat())
+      }
+
+      return locationParamsBuilder.build()
+    }
+
+    private fun mapAccuracyToPriority(accuracy: Int): Int {
+      return when (accuracy) {
+        LocationModule.ACCURACY_BEST_FOR_NAVIGATION, LocationModule.ACCURACY_HIGHEST, LocationModule.ACCURACY_HIGH -> Priority.PRIORITY_HIGH_ACCURACY
+        LocationModule.ACCURACY_BALANCED, LocationModule.ACCURACY_LOW -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+        LocationModule.ACCURACY_LOWEST -> Priority.PRIORITY_LOW_POWER
+        else -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+      }
+    }
+
+    private fun buildLocationParamsForAccuracy(accuracy: Int): LocationParams.Builder {
+      return when (accuracy) {
+        LocationModule.ACCURACY_LOWEST -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.LOWEST)
+          .setDistance(3000f)
+          .setInterval(10000)
+
+        LocationModule.ACCURACY_LOW -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.LOW)
+          .setDistance(1000f)
+          .setInterval(5000)
+
+        LocationModule.ACCURACY_BALANCED -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.MEDIUM)
+          .setDistance(100f)
+          .setInterval(3000)
+
+        LocationModule.ACCURACY_HIGH -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.HIGH)
+          .setDistance(50f)
+          .setInterval(2000)
+
+        LocationModule.ACCURACY_HIGHEST -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.HIGH)
+          .setDistance(25f)
+          .setInterval(1000)
+
+        LocationModule.ACCURACY_BEST_FOR_NAVIGATION -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.HIGH)
+          .setDistance(0f)
+          .setInterval(500)
+
+        else -> LocationParams.Builder()
+          .setAccuracy(LocationAccuracy.MEDIUM)
+          .setDistance(100f)
+          .setInterval(3000)
+      }
+    }
+
+    fun isAnyProviderAvailable(context: Context?): Boolean {
+      val locationManager = context?.getSystemService(Context.LOCATION_SERVICE) as? LocationManager ?: return false
+      return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) || locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
+    }
+
+    // Decorator for Permissions.getPermissionsWithPermissionsManager, for use in Kotlin coroutines
+    internal suspend fun getPermissionsWithPermissionsManager(contextPermissions: Permissions, vararg permissionStrings: String): PermissionRequestResponse {
+      return suspendCoroutine { continuation ->
+        Permissions.getPermissionsWithPermissionsManager(
+          contextPermissions,
+          object : Promise {
+            override fun resolve(value: Any?) {
+              val result = value as? Bundle ?: throw ConversionException(Any::class.java, Bundle::class.java, "value returned by the permission promise is not a Bundle")
+              continuation.resume(PermissionRequestResponse(result))
+            }
+
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+              continuation.resumeWithException(CodedException(code, message, cause))
+            }
+          },
+          *permissionStrings
+        )
+      }
+    }
+
+    // Decorator for Permissions.getPermissionsWithPermissionsManager, for use in Kotlin coroutines
+    internal suspend fun askForPermissionsWithPermissionsManager(contextPermissions: Permissions, vararg permissionStrings: String): Bundle {
+      return suspendCoroutine {
+        Permissions.askForPermissionsWithPermissionsManager(
+          contextPermissions,
+          object : Promise {
+            override fun resolve(value: Any?) {
+              it.resume(value as? Bundle ?: throw ConversionException(Any::class.java, Bundle::class.java, "value returned by the permission promise is not a Bundle"))
+            }
+
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+              it.resumeWithException(CodedException(code, message, cause))
+            }
+          },
+          *permissionStrings
+        )
+      }
+    }
+  }
+}
+
+/**
+ * A singleton that keeps information about whether the app is in the foreground or not.
+ * This is a simple solution for passing current foreground information from the LocationModule to LocationTaskConsumer.
+ */
+object AppForegroundedSingleton {
+  var isForegrounded = false
+}