Android传感器数据采集时获取经纬度的实现方案咨询

Hey there! Let's tackle your problem head-on—first, let's clear up the big question, then walk through modifying your code to add location tracking.

核心疑问：室内每20ms获取精准经纬度可行吗？ #

Short answer: No, it's not realistic. Here's why:

• GPS signals are weak or non-existent indoors, so satellite-based positioning can't deliver high-frequency updates here.
• Indoor positioning tech (like WiFi fingerprinting, Bluetooth beacons) has update intervals measured in seconds, not milliseconds, and accuracy ranges from 2-10 meters at best.
• Even Android's best location APIs (like Fused Location Provider) can't hit 20ms updates indoors—hardware and signal constraints simply don't allow it.

That said, we can implement the best possible location tracking for your use case, which will give you the most frequent updates available indoors, and integrate it with your existing sensor data.

代码修改方案 #

We'll use Google's Fused Location Provider (the recommended way to handle location on Android) to get location updates, then merge that data with your accelerometer/magnetometer readings in the CSV.

Step 1: Add Dependencies #

First, add the Fused Location dependency to your app-level build.gradle (Module level):

dependencies {
    // ... your existing dependencies
    implementation "com.google.android.gms:play-services-location:21.0.1"
}

Step 2: Update Permissions in AndroidManifest.xml #

Add these location permissions alongside your existing storage permissions:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<!-- Optional: Use only if you need background location tracking -->
<!-- <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" /> -->

Step 3: Modified MainActivity Code #

Here's the full updated code, with comments highlighting new additions:

public class MainActivity extends AppCompatActivity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor magnetic;
    private int counter = 1;
    private boolean recording = false;
    private float magValues[] = new float[3];
    private Context context;
    private static final int REQUESTCODE_STORAGE_PERMISSION = 1;
    private static final int REQUESTCODE_LOCATION_PERMISSION = 2;
    Collection<String[]> magneticData = new ArrayList<>();
    private CsvWriter csvWriter = null;
    public static DecimalFormat DECIMAL_FORMATTER;
    TextView stateText;
    EditText fileIDEdit;
    TextView magText;

    // NEW CODE: Location-related variables
    private FusedLocationProviderClient fusedLocationClient;
    private LocationCallback locationCallback;
    private double currentLatitude = Double.NaN; // Default to NaN if no location signal
    private double currentLongitude = Double.NaN;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        findViewById(R.id.button).setOnClickListener(listenerStartButton);
        findViewById(R.id.button2).setOnClickListener(listenerStopButton);
        fileIDEdit = findViewById(R.id.editText);
        magText = findViewById(R.id.textView3);
        stateText = findViewById(R.id.textView);
        stateText.setText("Stand by");
        context = this;

        // Sensor initialization
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        magnetic = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

        DecimalFormatSymbols symbols = new DecimalFormatSymbols(Locale.US);
        symbols.setDecimalSeparator('.');
        DECIMAL_FORMATTER = new DecimalFormat("#.000", symbols);

        // NEW CODE: Initialize Location Client and Callback
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
        setupLocationCallback();
    }

    // NEW CODE: Setup location update callback
    private void setupLocationCallback() {
        locationCallback = new LocationCallback() {
            @Override
            public void onLocationResult(LocationResult locationResult) {
                if (locationResult == null) return;
                Location location = locationResult.getLastLocation();
                if (location != null) {
                    currentLatitude = location.getLatitude();
                    currentLongitude = location.getLongitude();
                }
            }
        };
    }

    // NEW CODE: Start location updates with highest possible frequency
    private void startLocationUpdates() {
        LocationRequest locationRequest = LocationRequest.create();
        locationRequest.setInterval(20); // Request 20ms updates (system will adjust based on signal)
        locationRequest.setFastestInterval(20);
        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);

        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper());
        }
    }

    // NEW CODE: Stop location updates
    private void stopLocationUpdates() {
        fusedLocationClient.removeLocationUpdates(locationCallback);
        // Reset location values when stopping
        currentLatitude = Double.NaN;
        currentLongitude = Double.NaN;
    }

    private View.OnClickListener listenerStartButton = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            // Check location permission before starting
            if (ActivityCompat.checkSelfPermission(MainActivity.this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
                ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, REQUESTCODE_LOCATION_PERMISSION);
                return;
            }

            recording = true;
            stateText.setText("Recording started");
            stateText.setTextColor(Color.parseColor("#FF0000"));

            // Start location updates when recording begins
            startLocationUpdates();
        }
    };

    private View.OnClickListener listenerStopButton = new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if(recording) {
                recording = false;
                counter = 0;
                String value = fileIDEdit.getText().toString();
                stateText.setText("Recording Stopped");
                stateText.setTextColor(Color.parseColor("#0000FF"));

                // Stop location updates when recording ends
                stopLocationUpdates();

                if (storagePermitted((Activity) context)){
                    csvWriter = new CsvWriter();
                    File file = new File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), "magnetic" + value + ".csv");
                    try {
                        csvWriter.write(file, StandardCharsets.UTF_8, magneticData);
                        Toast.makeText(MainActivity.this, "File is recorded in memory.", Toast.LENGTH_LONG).show();
                    } catch (IOException io) {
                        Log.d("Error", io.getLocalizedMessage());
                    }
                }
            } else{
                Toast.makeText(MainActivity.this, "Nothing to save. Recording was not started.", Toast.LENGTH_LONG).show();
            }
        }
    };

    @Override
    protected void onResume(){
        super.onResume();
        sensorManager.registerListener(this, magnetic, SensorManager.SENSOR_DELAY_GAME);
    }

    @Override
    protected void onPause() {
        super.onPause();
        sensorManager.unregisterListener(this);
        // Stop location updates if app is paused to save battery
        if (recording) {
            stopLocationUpdates();
        }
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        long timeInMillisec = (new Date()).getTime() + (event.timestamp - System.nanoTime()) / 1000000L;
        if(recording) {
            float x = 0;
            float y = 0;
            float z = 0;
            double magnitude = 0;

            if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
                x = event.values[0];
                y = event.values[1];
                z = event.values[2];
                magnitude = Math.sqrt((x * x) + (y * y) + (z * z)); // Fixed your magnitude calculation (was y+y instead of y*y)
                magText.setText("Magnetometer: X= " + x + " Y= " + y + " Z= " + z + " Magnitude: " + DECIMAL_FORMATTER.format(magnitude) + "\u00b5Tesla");
                Log.d("Record", "Magnetometer" + String.valueOf(counter));
                magValues = event.values;
            }

            @SuppressLint("SimpleDateFormat")
            SimpleDateFormat logLineStamp = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss:SSS", Locale.getDefault());
            // NEW CODE: Add latitude and longitude to the CSV row
            magneticData.add(new String[]{
                    logLineStamp.format(new Date(timeInMillisec)),
                    String.valueOf(x),
                    String.valueOf(y),
                    String.valueOf(z),
                    String.valueOf(magnitude),
                    String.valueOf(currentLatitude),
                    String.valueOf(currentLongitude)
            });
            counter++;
        }
    }

    // Checks if storage permissions are granted
    private static boolean storagePermitted(Activity activity){
        Boolean readPermission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
        Boolean writePermission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED;
        if (readPermission && writePermission){
            return true;
        }
        ActivityCompat.requestPermissions(activity, new String[]{
                Manifest.permission.READ_EXTERNAL_STORAGE,
                Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUESTCODE_STORAGE_PERMISSION);
        return false;
    }

    public static float roundThis(float value){
        BigDecimal bd = new BigDecimal(value);
        bd = bd.setScale(4, RoundingMode.HALF_UP);
        return bd.floatValue();
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) { }

    // NEW CODE: Handle location permission result
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUESTCODE_LOCATION_PERMISSION) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // Permission granted, start recording and location updates
                recording = true;
                stateText.setText("Recording started");
                stateText.setTextColor(Color.parseColor("#FF0000"));
                startLocationUpdates();
            } else {
                Toast.makeText(this, "Location permission is required to record coordinates", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

Key Changes Explained #

1. Location Client Setup: We added FusedLocationProviderClient—the modern, efficient way to handle location requests on Android.
2. Location Callback: Listens for new location updates and keeps our latitude/longitude variables up to date.
3. Permission Handling: Added checks for location permission before starting recording, plus a callback to handle user responses.
4. CSV Data Expansion: Each CSV row now includes latitude and longitude (shows NaN if no location signal is available).
5. Fixed Magnitude Calculation: Corrected your typo (y + y → y * y) to get accurate magnetometer magnitude readings.
6. Lifecycle Management: Stops location updates when the app is paused or recording stops to save battery.

Final Notes #

• Indoor Limitations: You won't get 20ms location updates indoors—expect updates every 1-5 seconds (if using WiFi/Bluetooth) or none at all if no signal is present.
• Battery Usage: High-frequency location requests drain battery fast—consider increasing setInterval to 1000ms if battery life is a priority.
• Heatmap Accuracy: For better indoor heatmaps, you might want to combine location with magnetometer fingerprinting (a more advanced project), but this code gives you a solid starting point.

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