Android中如何对比用户定位与Assets中CSV坐标并返回邻近地点

Hey there! As someone who’s fumbled through Android location handling and CSV parsing as a beginner, let’s break this down into manageable steps so you can get this working smoothly. I’ll cover everything from permissions to the full integration of your logic.

First, you need to grant your app permission to access the device’s location. Open your AndroidManifest.xml and add these lines inside the <manifest> tag (before <application>):

<!-- Required for precise GPS location -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<!-- Fallback for devices without GPS -->
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Note: On Android 6.0 (API level 23) and above, you’ll also need to request these permissions dynamically at runtime. I’ll include a snippet for that in the full code later.

Let’s make a simple class to store the location data from your CSV. This will make it way easier to work with the data later:

public class Place {
    private double latitude;
    private double longitude;
    private String name;

    public Place(double latitude, double longitude, String name) {
        this.latitude = latitude;
        this.longitude = longitude;
        this.name = name;
    }

    // Getters to access our fields
    public double getLatitude() { return latitude; }
    public double getLongitude() { return longitude; }
    public String getName() { return name; }
}

Next, we’ll write a method to load and parse the data.csv file from your Assets folder. This will return a list of Place objects we can use to compare against the user’s location:

private List<Place> loadPlacesFromAssets() {
    List<Place> places = new ArrayList<>();
    BufferedReader reader = null;

    try {
        // Open the CSV file from the assets folder
        InputStream is = getContext().getAssets().open("data.csv");
        reader = new BufferedReader(new InputStreamReader(is));

        // Skip the header line (lat_c, long_c, placeName)
        String line = reader.readLine();

        // Read each subsequent line of the CSV
        while ((line = reader.readLine()) != null) {
            // Split the line by commas, and trim whitespace to avoid parsing errors
            String[] parts = line.split(",");
            if (parts.length == 3) {
                double lat = Double.parseDouble(parts[0].trim());
                double lng = Double.parseDouble(parts[1].trim());
                String name = parts[2].trim();
                places.add(new Place(lat, lng, name));
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
        // Show a user-friendly error if loading fails
        Toast.makeText(getContext(), "Failed to load location data", Toast.LENGTH_SHORT).show();
    } finally {
        try {
            if (reader != null) reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return places;
}

Android’s Location class has a built-in method to calculate the distance between two coordinates. We’ll use this to check if the user is close enough to a place. Let’s define a distance threshold (e.g., 50 meters—you can adjust this to your needs):

private static final int DISTANCE_THRESHOLD_METERS = 50;

private boolean isUserNearPlace(Location userLocation, Place place) {
    float[] distance = new float[1];
    // Calculate the distance in meters between the user and the place
    Location.distanceBetween(
        userLocation.getLatitude(), userLocation.getLongitude(),
        place.getLatitude(), place.getLongitude(),
        distance
    );
    // Return true if the distance is below our threshold
    return distance[0] <= DISTANCE_THRESHOLD_METERS;
}

Now let’s put it all together. We’ll update your location listener to check against the loaded places, and handle permission requests first:

Full Fragment/Activity Code Example #

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.fragment.app.Fragment;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class LocationCheckerFragment extends Fragment {
    private LocationManager locationManager;
    private List<Place> placesList;
    private static final int LOCATION_PERMISSION_REQUEST_CODE = 100;
    private static final int DISTANCE_THRESHOLD_METERS = 50;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Load places from CSV when the fragment starts
        placesList = loadPlacesFromAssets();
        // Initialize LocationManager
        locationManager = (LocationManager) getContext().getSystemService(Context.LOCATION_SERVICE);
    }

    // Attach this to your button in XML with android:onClick="onCheckLocationButtonClicked"
    public void onCheckLocationButtonClicked(View view) {
        // Check if we have location permission
        if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // Request permission if not granted
            ActivityCompat.requestPermissions(requireActivity(),
                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    LOCATION_PERMISSION_REQUEST_CODE);
            return;
        }

        // Start listening for location updates
        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
        Toast.makeText(getContext(), "Fetching your location...", Toast.LENGTH_SHORT).show();
    }

    private final LocationListener locationListener = new LocationListener() {
        @Override
        public void onLocationChanged(@NonNull Location location) {
            // Stop listening for updates once we get a valid location (optional)
            locationManager.removeUpdates(this);

            // Check if the user is near any place in the CSV
            for (Place place : placesList) {
                if (isUserNearPlace(location, place)) {
                    // Found a nearby place!
                    Toast.makeText(getContext(), "True - Near " + place.getName(), Toast.LENGTH_LONG).show();
                    // You can also pass this result to a callback or store it as needed
                    return;
                }
            }

            // No nearby places found
            Toast.makeText(getContext(), "False - No nearby places detected", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {}

        @Override
        public void onProviderEnabled(@NonNull String provider) {}

        @Override
        public void onProviderDisabled(@NonNull String provider) {
            Toast.makeText(getContext(), "GPS is disabled! Please enable it to use this feature.", Toast.LENGTH_LONG).show();
        }
    };

    private List<Place> loadPlacesFromAssets() {
        List<Place> places = new ArrayList<>();
        BufferedReader reader = null;

        try {
            InputStream is = getContext().getAssets().open("data.csv");
            reader = new BufferedReader(new InputStreamReader(is));
            String line = reader.readLine(); // Skip the header line

            while ((line = reader.readLine()) != null) {
                String[] parts = line.split(",");
                if (parts.length == 3) {
                    double lat = Double.parseDouble(parts[0].trim());
                    double lng = Double.parseDouble(parts[1].trim());
                    String name = parts[2].trim();
                    places.add(new Place(lat, lng, name));
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            Toast.makeText(getContext(), "Failed to load location data", Toast.LENGTH_SHORT).show();
        } finally {
            try {
                if (reader != null) reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return places;
    }

    private boolean isUserNearPlace(Location userLocation, Place place) {
        float[] distance = new float[1];
        Location.distanceBetween(
                userLocation.getLatitude(), userLocation.getLongitude(),
                place.getLatitude(), place.getLongitude(),
                distance
        );
        return distance[0] <= DISTANCE_THRESHOLD_METERS;
    }

    // Handle permission request result
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == LOCATION_PERMISSION_REQUEST_CODE) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted - start location updates
                if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
                    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);
                    Toast.makeText(getContext(), "Fetching your location...", Toast.LENGTH_SHORT).show();
                }
            } else {
                Toast.makeText(getContext(), "Location permission is required to check nearby places", Toast.LENGTH_LONG).show();
            }
        }
    }

    // Place model class
    private static class Place {
        private double latitude;
        private double longitude;
        private String name;

        public Place(double latitude, double longitude, String name) {
            this.latitude = latitude;
            this.longitude = longitude;
            this.name = name;
        }

        public double getLatitude() { return latitude; }
        public double getLongitude() { return longitude; }
        public String getName() { return name; }
    }
}

• Permission Handling: Don’t skip the dynamic permission request—Android 6+ will block your app from accessing location otherwise.
• CSV Parsing: The trim() calls are crucial because your CSV has spaces after commas (e.g., 37.004934,-122.783378, place1). Without trimming, parsing the double values will throw an error.
• Location Updates: I added locationManager.removeUpdates(this) in onLocationChanged to stop listening once we get a location (remove this if you want continuous updates).
• Distance Threshold: Adjust DISTANCE_THRESHOLD_METERS to whatever makes sense for your use case (e.g., 100 meters for broader detection).

内容的提问来源于stack exchange，提问作者Allen