如何通过传感器获取Android设备的Position和Pan信息

Hey there! I totally get why you're frustrated with the accelerometer-only approach for position tracking—those values drift like crazy over time, right? Let's break down how to reliably get both your Pan (camera panning) and 3D Position data to pair with your camera stream.

First: Pan (Camera Panning) #

Pan is essentially the horizontal rotation of your device (left/right tilt around the vertical axis). The most accurate way to get this is using the Rotation Vector Sensor, which fuses data from the gyroscope, accelerometer, and magnetometer to give stable orientation readings—way better than relying on a single sensor.

Here's a quick implementation example:

private SensorManager sensorManager;
private Sensor rotationVectorSensor;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    rotationVectorSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
}

@Override
protected void onResume() {
    super.onResume();
    // Register listener with game-level delay (balanced for accuracy/performance)
    sensorManager.registerListener(sensorEventListener, rotationVectorSensor, SensorManager.SENSOR_DELAY_GAME);
}

@Override
protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(sensorEventListener);
}

private final SensorEventListener sensorEventListener = new SensorEventListener() {
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() != Sensor.TYPE_ROTATION_VECTOR) return;

        float[] rotationMatrix = new float[9];
        SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values);
        
        // Get orientation angles: azimuth (pan), pitch, roll
        float[] orientation = new float[3];
        SensorManager.getOrientation(rotationMatrix, orientation);
        
        // Convert azimuth from radians to degrees (easier to work with)
        float panDegrees = (float) Math.toDegrees(orientation[0]);
        
        // Adjust for your app's coordinate system if needed (e.g., normalize to 0-360 range)
        panDegrees = (panDegrees + 360) % 360;
        
        // Now you can send this panDegrees value as your Pan data!
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Handle cases where sensor accuracy drops (e.g., magnetometer interfered with by metal)
        if (accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE) {
            // Maybe show a warning to the user
        }
    }
};

Second: 3D Position (Device Location in Space) #

This is trickier because pure inertial sensors (accelerometer + gyro) have unavoidable drift. You'll need to combine sensor data with other positioning sources depending on your use case:

Option 1: Absolute Outdoor Position (Lat/Lng/Altitude) #

For outdoor use, Google's Fused Location Provider is the way to go—it fuses GPS, WiFi, and cell tower data for accurate, low-power position updates.

private FusedLocationProviderClient fusedLocationClient;
private LocationCallback locationCallback;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
    
    // First, check for location permissions
    if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 1001);
        return;
    }
    
    // Set up location updates
    locationCallback = new LocationCallback() {
        @Override
        public void onLocationResult(LocationResult locationResult) {
            if (locationResult == null) return;
            
            for (Location location : locationResult.getLocations()) {
                // Get 3D position values
                double latitude = location.getLatitude();
                double longitude = location.getLongitude();
                double altitude = location.getAltitude();
                
                // Send these as your Position data (you can convert to meters relative to a point if needed)
            }
        }
    };
    
    LocationRequest locationRequest = new LocationRequest()
            .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
            .setInterval(1000) // Update every 1 second (adjust based on your needs)
            .setFastestInterval(500);
    
    fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper());
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (fusedLocationClient != null && locationCallback != null) {
        fusedLocationClient.removeLocationUpdates(locationCallback);
    }
}

Option 2: Relative Indoor/AR Position #

If you need position relative to a starting point (e.g., indoor navigation or AR apps), ARCore (or Google Play Services AR) provides precise 3D pose tracking that combines camera vision with sensor data to minimize drift.

Here's a simplified snippet:

private Session arSession;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Initialize ARCore session
    try {
        arSession = new Session(this);
        Config config = new Config(arSession);
        if (!arSession.isSupported(config)) {
            // Handle device not supporting ARCore
            return;
        }
        arSession.configure(config);
    } catch (UnavailableException e) {
        // Handle ARCore unavailable
        e.printStackTrace();
    }
}

// In your frame rendering loop (e.g., in a GLSurfaceView.Renderer)
public void onDrawFrame(GL10 gl) {
    if (arSession == null) return;
    
    Frame frame = arSession.update();
    Camera camera = frame.getCamera();
    
    // Only use data if tracking is stable
    if (camera.getTrackingState() == TrackingState.TRACKING) {
        Pose devicePose = camera.getPose();
        
        // Get relative position (x, y, z) from the initial starting point
        float relativeX = devicePose.tx();
        float relativeY = devicePose.ty();
        float relativeZ = devicePose.tz();
        
        // Send these as your relative Position data!
    }
}

Critical Notes for Position Tracking #

• Avoid pure inertial navigation: Accelerometer integration will drift drastically even after a few seconds—always combine with GPS, vision (ARCore), or WiFi/Bluetooth beacons.
• Permissions: Make sure you request the appropriate permissions (ACCESS_FINE_LOCATION for GPS, CAMERA for ARCore).
• Accuracy vs. Performance: Adjust sensor/update intervals based on your app's needs—higher frequency means more data but more battery usage.

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