Question: I am writing my own background location updates for interval of every 5 minutes in android. I would like to know the difference between setInterval and setFastestInterval 

When I setInterval to 5 mins and setFastestInterval to 2 mins. The location update is called every 2 mins.

I would like to know the difference. I couldn't understand what exactly is written in the developer page for this <https://developer.android.com/reference/com/google/android/gms/location/LocationRequest.html>

Also: Is there an inbuilt function to check the location updates only if the distances of the first update are more than 20meters with the second update? 

Thanks!

Answer: 
Based on the relevant [Android documentation](https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest):

* `setInterval(long)` means - set the interval in which you want to get locations.
* `setFastestInterval(long)` means - if a location is available sooner you can get it (i.e. another app is using the location services).

For example, you start your application and register it via `setInterval(60*1000)`, that means that you'll get updates every 60 seconds.

Now you call `setFastestInterval(10*1000)`. If you are the only app which use the location services you will continue to receive updates approximately every 60 seconds. If another app is using the location services with a higher rate of updates, you will get more location updates (but no more frequently that every 10 seconds).

I believe that it has a good impact on battery life consumed by your app, you define the maximum amount of time that you can wait while saying that if an update is available, you want it. The battery consumption will be credited to the app which requested the more frequent updates and not yours.
> 
> I am writing my own background location updates for interval of every *5 minutes* in android. I would like to know the difference between `setInterval`and `setFastestInterval` 
> 
> 
> 

Assume that the `setFastestInterval();` has higher priority for requesting a `Location`. To whatever app you set the `setFastestInterval();` it will be that app that will be executed first (even if other apps are using `LocationServices`). 

ex: If **APP1** has `setFastestInterval(1000 * 10)` and **APP2** has `setInterval(1000 * 10)`, **both APPS** have same request interval. But it is the **APP1** that will make the first request. (this is what i have understood, the answer is not correct maybe)

> 
> When I `setInterval` to *5 mins* and `setFastestInterval` to *2 mins*. The `location update` is called every *2 mins*.
> 
> 
> 

If you are using `setFastestInterval()` together with the `setInterval()` the app will try to make a request for the time given in the `setFastestInterval()`, that's why your app makes a request every *2mins*.

> 
> Also: Is there an inbuilt function to check the location updates only if the distances of the first update are more than 20meters with the second update? 
> 
> 
> 

For Making request every 20 meters you can create a `LocationModel`

```
    public class LocationModel {
    private double latitude;

    private double longitude;
    public LocationModel(){
    }

    public double getLatitude() {
        return latitude;
    }

    public void setLatitude(double latitude) {
        this.latitude = latitude;
    }

    public double getLongitude() {
        return longitude;
    }

    public void setLongitude(double longitude) {
        this.longitude = longitude;
    }
}

```

and in the first request you set the `lat` and `long` to current location (using `getLastLocation();`) 

then `onLocationChanged()` you get the data from the object and compare with the `new Current Location` 

```
float distanceInMeters = distFrom((float)locationObj.getLatitude(), (float)locationObj.getLongitude(), (float)mCurrentLocation.getLatitude(), (float)mCurrentLocation.getLongitude());

```

using this function which is also a suggestion of users of `SO`

```
public static float distFrom(float lat1, float lng1, float lat2, float lng2) {
    double earthRadius = 6371; //kilometers
    double dLat = Math.toRadians(lat2-lat1);
    double dLng = Math.toRadians(lng2-lng1);
    double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
            Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
                    Math.sin(dLng/2) * Math.sin(dLng/2);
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    float dist = (float) (earthRadius * c);

    return dist;
}

```