A Comprehensive Guide to Calculating Distance Between Two Points in Android Google Maps API V2

Background and Challenges

In Android app development, integrating Google Maps API V2 allows developers to display maps and add markers. However, calculating the actual distance between two marker points is a common requirement. This article delves into several calculation methods, focusing on the implementation based on the Haversine formula and providing code examples.

Core Method: Using the Haversine Formula for Distance Calculation

The Haversine formula is an algorithm used to calculate the great-circle distance between two points on a sphere, suitable for Earth surface distance calculations. Here is a custom method implementation based on the best answer:

public double CalculationByDistance(LatLng StartP, LatLng EndP) {
    int Radius = 6371; // Earth radius in kilometers
    double lat1 = StartP.latitude;
    double lat2 = EndP.latitude;
    double lon1 = StartP.longitude;
    double lon2 = EndP.longitude;
    double dLat = Math.toRadians(lat2 - lat1);
    double dLon = Math.toRadians(lon2 - lon1);
    double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
            + Math.cos(Math.toRadians(lat1))
            * Math.cos(Math.toRadians(lat2)) * Math.sin(dLon / 2)
            * Math.sin(dLon / 2);
    double c = 2 * Math.asin(Math.sqrt(a));
    double valueResult = Radius * c;
    // Optional: formatting and logging
    DecimalFormat newFormat = new DecimalFormat("####");
    int kmInDec = Integer.valueOf(newFormat.format(valueResult / 1));
    double meter = valueResult % 1000;
    int meterInDec = Integer.valueOf(newFormat.format(meter));
    Log.i("Radius Value", "" + valueResult + "   KM  " + kmInDec + " Meter   " + meterInDec);
    return valueResult;
}

This method first converts latitude and longitude to radians, then applies the Haversine formula to calculate distance in kilometers. The logging output aids in debugging, but the core calculation is accurate.

Alternative Method: Utilizing the Android Location Class

The Android platform provides the Location class, which includes a static distanceBetween method to simplify distance calculation:

float[] results = new float[1];
Location.distanceBetween(oldPosition.latitude, oldPosition.longitude,
        newPosition.latitude, newPosition.longitude, results);
// Distance is stored in results[0] in meters

This method relies on built-in geographical calculations, often more efficient and easier to use, but depends on the Android framework.

Third-Party Library Method: Google SphericalUtil

For more advanced applications, Google provides utility libraries like SphericalUtil, which includes the computeDistanceBetween method:

double distance = SphericalUtil.computeDistanceBetween(latLngFrom, latLngTo); // in meters

Using this method requires adding a dependency for the Google Maps Android API Utility library, suitable for scenarios needing more geographical computation features.

Method Comparison and Best Practices

Comparing the three methods: the Haversine formula offers custom control and cross-platform compatibility; Location.distanceBetween has high integration, ideal for standard Android apps; SphericalUtil is suited for complex geographical operations. The choice depends on application needs: for simple distance calculations, the Location class is sufficient; for custom or non-Android environments, the Haversine formula is a reliable choice.

Conclusion

Calculating the distance between two points in Google Maps API V2 can be done through various methods. Developers should choose based on specific scenarios. The Haversine formula, as a core method, provides flexibility and precision, while system methods and third-party libraries simplify implementation. By understanding these technologies, app performance can be optimized for better user experience.