Merge pull request #983 from maskaravivek/nearbyRefactoring

Fix issues around location in nearby activity

Author: misaochan

app/build.gradle

@@ -78,7 +78,6 @@ android {
 
     defaultConfig {
         applicationId 'fr.free.nrw.commons'
-
         versionCode 76
         versionName '2.6.1'
         setProperty("archivesBaseName", "app-commons-v$versionName-" + getBranchName())

app/src/main/AndroidManifest.xml

@@ -16,6 +16,9 @@
     <uses-permission android:name="com.google.android.apps.photos.permission.GOOGLE_PHOTOS"/>
     <uses-permission android:name="android.permission.READ_LOGS"/>
 
+    <!-- Needed only if your app targets Android 5.0 (API level 21) or higher. -->
+    <uses-feature android:name="android.hardware.location.gps" />
+
     <application
         android:name=".CommonsApplication"
         android:icon="@drawable/ic_launcher"

app/src/main/java/fr/free/nrw/commons/location/LatLng.java

@@ -1,5 +1,8 @@
 package fr.free.nrw.commons.location;
 
+import android.location.Location;
+import android.support.annotation.NonNull;
+
 public class LatLng {
 
     private final double latitude;
@@ -22,6 +25,10 @@ public LatLng(double latitude, double longitude, float accuracy) {
         this.accuracy = accuracy;
     }
 
+    public static LatLng from(@NonNull Location location) {
+        return new LatLng(location.getLatitude(), location.getLongitude(), location.getAccuracy());
+    }
+
     public int hashCode() {
         boolean var1 = true;
         byte var2 = 1;

app/src/main/java/fr/free/nrw/commons/location/LocationServiceManager.java

@@ -1,11 +1,15 @@
 package fr.free.nrw.commons.location;
 
+import android.Manifest;
+import android.app.Activity;
 import android.content.Context;
-import android.location.Criteria;
+import android.content.pm.PackageManager;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
 import android.os.Bundle;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.content.ContextCompat;
 
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
@@ -17,59 +21,136 @@
 
 @Singleton
 public class LocationServiceManager implements LocationListener {
+    public static final int LOCATION_REQUEST = 1;
 
-    private String provider;
+    private static final long MIN_LOCATION_UPDATE_REQUEST_TIME_IN_MILLIS = 2 * 60 * 1000;
+    private static final long MIN_LOCATION_UPDATE_REQUEST_DISTANCE_IN_METERS = 10;
+
+    private Context context;
     private LocationManager locationManager;
-    private LatLng lastLocation;
-    private Float latestLocationAccuracy;
+    private Location lastLocation;
     private final List<LocationUpdateListener> locationListeners = new CopyOnWriteArrayList<>();
+    private boolean isLocationManagerRegistered = false;
 
     @Inject
     public LocationServiceManager(Context context) {
+        this.context = context;
         this.locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
-        provider = locationManager.getBestProvider(new Criteria(), true);
     }
 
     public boolean isProviderEnabled() {
         return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
     }
 
-    public LatLng getLastLocation() {
-        return lastLocation;
+    public boolean isLocationPermissionGranted() {
+        return ContextCompat.checkSelfPermission(context,
+                Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
     }
 
-    /**
-     * Returns the accuracy of the location. The measurement is
-     * given as a radius in meter of 68 % confidence.
-     *
-     * @return Float
-     */
-    public Float getLatestLocationAccuracy() {
-        return latestLocationAccuracy;
+    public void requestPermissions(Activity activity) {
+        if (activity.isFinishing()) {
+            return;
+        }
+        ActivityCompat.requestPermissions(activity,
+                new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
+                LOCATION_REQUEST);
+    }
+
+    public boolean isPermissionExplanationRequired(Activity activity) {
+        if (activity.isFinishing()) {
+            return false;
+        }
+        return ActivityCompat.shouldShowRequestPermissionRationale(activity,
+                Manifest.permission.ACCESS_FINE_LOCATION);
+    }
+
+    public LatLng getLastLocation() {
+        if (lastLocation == null) {
+            return null;
+        }
+        return LatLng.from(lastLocation);
     }
 
     /** Registers a LocationManager to listen for current location.
      */
     public void registerLocationManager() {
+        if (!isLocationManagerRegistered)
+            isLocationManagerRegistered = requestLocationUpdatesFromProvider(LocationManager.NETWORK_PROVIDER)
+                    && requestLocationUpdatesFromProvider(LocationManager.GPS_PROVIDER);
+    }
+
+    private boolean requestLocationUpdatesFromProvider(String locationProvider) {
         try {
-            locationManager.requestLocationUpdates(provider, 400, 1, this);
-            Location location = locationManager.getLastKnownLocation(provider);
-            //Location works, just need to 'send' GPS coords
-            // via emulator extended controls if testing on emulator
-            Timber.d("Checking for location...");
-            if (location != null) {
-                this.onLocationChanged(location);
-            }
+            locationManager.requestLocationUpdates(locationProvider,
+                    MIN_LOCATION_UPDATE_REQUEST_TIME_IN_MILLIS,
+                    MIN_LOCATION_UPDATE_REQUEST_DISTANCE_IN_METERS,
+                    this);
+            return true;
         } catch (IllegalArgumentException e) {
             Timber.e(e, "Illegal argument exception");
+            return false;
         } catch (SecurityException e) {
             Timber.e(e, "Security exception");
+            return false;
+        }
+    }
+
+    protected boolean isBetterLocation(Location location, Location currentBestLocation) {
+        if (currentBestLocation == null) {
+            // A new location is always better than no location
+            return true;
+        }
+
+        // Check whether the new location fix is newer or older
+        long timeDelta = location.getTime() - currentBestLocation.getTime();
+        boolean isSignificantlyNewer = timeDelta > MIN_LOCATION_UPDATE_REQUEST_TIME_IN_MILLIS;
+        boolean isSignificantlyOlder = timeDelta < -MIN_LOCATION_UPDATE_REQUEST_TIME_IN_MILLIS;
+        boolean isNewer = timeDelta > 0;
+
+        // If it's been more than two minutes since the current location, use the new location
+        // because the user has likely moved
+        if (isSignificantlyNewer) {
+            return true;
+            // If the new location is more than two minutes older, it must be worse
+        } else if (isSignificantlyOlder) {
+            return false;
+        }
+
+        // Check whether the new location fix is more or less accurate
+        int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
+        boolean isLessAccurate = accuracyDelta > 0;
+        boolean isMoreAccurate = accuracyDelta < 0;
+        boolean isSignificantlyLessAccurate = accuracyDelta > 200;
+
+        // Check if the old and new location are from the same provider
+        boolean isFromSameProvider = isSameProvider(location.getProvider(),
+                currentBestLocation.getProvider());
+
+        // Determine location quality using a combination of timeliness and accuracy
+        if (isMoreAccurate) {
+            return true;
+        } else if (isNewer && !isLessAccurate) {
+            return true;
+        } else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
+            return true;
         }
+        return false;
+    }
+
+    /**
+     * Checks whether two providers are the same
+     */
+    private boolean isSameProvider(String provider1, String provider2) {
+        if (provider1 == null) {
+            return provider2 == null;
+        }
+        return provider1.equals(provider2);
     }
 
     /** Unregisters location manager.
      */
     public void unregisterLocationManager() {
+        isLocationManagerRegistered = false;
         try {
             locationManager.removeUpdates(this);
         } catch (SecurityException e) {
@@ -89,15 +170,11 @@ public void removeLocationListener(LocationUpdateListener listener) {
 
     @Override
     public void onLocationChanged(Location location) {
-        double currentLatitude = location.getLatitude();
-        double currentLongitude = location.getLongitude();
-        latestLocationAccuracy = location.getAccuracy();
-        Timber.d("Latitude: %f Longitude: %f Accuracy %f",
-                currentLatitude, currentLongitude, latestLocationAccuracy);
-        lastLocation = new LatLng(currentLatitude, currentLongitude, latestLocationAccuracy);
-
-        for (LocationUpdateListener listener : locationListeners) {
-            listener.onLocationChanged(lastLocation);
+        if (isBetterLocation(location, lastLocation)) {
+            lastLocation = location;
+            for (LocationUpdateListener listener : locationListeners) {
+                listener.onLocationChanged(LatLng.from(lastLocation));
+            }
         }
     }