fix: Administrative area in Location Detection

app/src/fdroid/java/org/fossasia/openevent/general/search/location/GeoLocationViewModel.kt

@@ -15,7 +15,7 @@ class GeoLocationViewModel(private val locationService: LocationService) : ViewM
     private val compositeDisposable = CompositeDisposable()
 
     fun configure() {
-        compositeDisposable += locationService.getAdministrativeArea()
+        compositeDisposable += locationService.getCityName()
             .subscribe({
                 mutableLocation.value = it
             }, {

app/src/fdroid/java/org/fossasia/openevent/general/search/location/LocationServiceImpl.kt

@@ -61,4 +61,47 @@ class LocationServiceImpl(
             }
         }
     }
+
+    @SuppressLint("MissingPermission")
+    override fun getCityName(): Single<String> {
+        val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+            ?: return Single.error(IllegalStateException())
+        val geoCoder = Geocoder(context, Locale.getDefault())
+
+        return Single.create { emitter ->
+            try {
+                locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0f,
+                    object : LocationListener {
+                        override fun onLocationChanged(location: Location?) {
+                            if (location == null) {
+                                emitter.onError(java.lang.IllegalStateException())
+                                return
+                            }
+                            val addresses = geoCoder.getFromLocation(location.latitude, location.longitude, 1)
+                            try {
+                                val adminArea = if (addresses.isNotEmpty()) addresses[0].locality
+                                else resource.getString(R.string.no_location).nullToEmpty()
+                                emitter.onSuccess(adminArea)
+                            } catch (e: IllegalArgumentException) {
+                                emitter.onError(e)
+                            }
+                        }
+
+                        override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {
+                            // To change body of created functions use File | Settings | File Templates.
+                        }
+
+                        override fun onProviderEnabled(provider: String?) {
+                            // To change body of created functions use File | Settings | File Templates.
+                        }
+
+                        override fun onProviderDisabled(provider: String?) {
+                            // To change body of created functions use File | Settings | File Templates.
+                        }
+                    })
+            } catch (e: SecurityException) {
+                emitter.onError(e)
+            }
+        }
+    }
 }

app/src/main/java/org/fossasia/openevent/general/search/location/LocationService.kt

@@ -11,4 +11,8 @@ interface LocationService {
      * Gives the administrative area of the current location the user is in.
      * */
     fun getAdministrativeArea(): Single<String>
+    /**
+     * Gives the city name of the current location the user is in.
+     * */
+    fun getCityName(): Single<String>
 }

app/src/playStore/java/org/fossasia/openevent/general/search/location/GeoLocationViewModel.kt

@@ -22,7 +22,7 @@ class GeoLocationViewModel(private val locationService: LocationService) : ViewM
     private val compositeDisposable = CompositeDisposable()
 
     fun configure() {
-        compositeDisposable += locationService.getAdministrativeArea()
+        compositeDisposable += locationService.getCityName()
             .subscribe(
                 { adminArea ->
                     mutableLocation.value = adminArea

app/src/playStore/java/org/fossasia/openevent/general/search/location/LocationServiceImpl.kt

@@ -63,6 +63,46 @@ class LocationServiceImpl(
         }
     }
 
+    override fun getCityName(): Single<String> {
+        val locationManager = context.getSystemService(Context.LOCATION_SERVICE)
+
+        if (locationManager !is LocationManager) {
+            return Single.error(IllegalStateException())
+        }
+
+        if (!locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
+            return Single.error(NoLocationSourceException())
+        }
+
+        val locationRequest = LocationRequest.create().apply {
+            priority = LocationRequest.PRIORITY_LOW_POWER
+        }
+        return Single.create { emitter ->
+            try {
+                LocationServices
+                    .getFusedLocationProviderClient(context)
+                    .requestLocationUpdates(locationRequest, object : LocationCallback() {
+
+                        override fun onLocationResult(locationResult: LocationResult?) {
+                            if (locationResult == null) {
+                                emitter.onError(IllegalStateException())
+                                return
+                            }
+                            try {
+                                val locality = locationResult.getLocality()
+                                emitter.onSuccess(locality)
+                            } catch (e: Exception) {
+                                Timber.e(e, "Error finding user current location")
+                                emitter.onSuccess(resource.getString(R.string.no_location).nullToEmpty())
+                            }
+                        }
+                    }, null)
+            } catch (e: SecurityException) {
+                emitter.onError(LocationPermissionException())
+            }
+        }
+    }
+
     private fun LocationResult.getAdminArea(): String {
         locations.filterNotNull().forEach { location ->
             val latitude = location.latitude
@@ -80,4 +120,22 @@ class LocationServiceImpl(
         }
         throw IllegalArgumentException()
     }
+
+    private fun LocationResult.getLocality(): String {
+        locations.filterNotNull().forEach { location ->
+            val latitude = location.latitude
+            val longitude = location.longitude
+            try {
+                val maxResults = 2
+                val geocoder = Geocoder(context, Locale.getDefault())
+                val addresses = geocoder.getFromLocation(latitude, longitude, maxResults)
+                val address = addresses.first { address -> address.locality != null }
+                return address.locality
+            } catch (exception: IOException) {
+                Timber.e(exception, "Error Fetching Location")
+                throw IllegalArgumentException()
+            }
+        }
+        throw IllegalArgumentException()
+    }
 }