Java Code Examples for android.hardware.Sensor#TYPE_ROTATION_VECTOR

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        // Get the current heading from the sensor, then notify the listeners of the
        // change.
        SensorManager.getRotationMatrixFromVector(mRotationMatrix, event.values);
        SensorManager.remapCoordinateSystem(mRotationMatrix, SensorManager.AXIS_X,
                SensorManager.AXIS_Z, mRotationMatrix);
        SensorManager.getOrientation(mRotationMatrix, mOrientation);

        // Store the pitch (used to display a message indicating that the user's head
        // angle is too steep to produce reliable results.
        mPitch = (float) Math.toDegrees(mOrientation[1]);

        // Convert the heading (which is relative to magnetic north) to one that is
        // relative to true north, using the user's current location to compute this.
        float magneticHeading = (float) Math.toDegrees(mOrientation[0]);
        mHeading = MathUtils.mod(computeTrueNorth(magneticHeading), 360.0f)
                - ARM_DISPLACEMENT_DEGREES;

        notifyOrientationChanged();
    }
}
 

@Override
public void onSensorChanged(final SensorEvent event) {
    if (isOn && event.accuracy != 0){
        if (getParams().mSensorListener != null){
            getParams().mSensorListener.onSensorChanged(event);
        }

        int type = event.sensor.getType();
        switch (type){
            case Sensor.TYPE_ROTATION_VECTOR:
                // post
                VRUtil.sensorRotationVector2Matrix(event, windowManager.getDefaultDisplay().getRotation(), mSensorMatrix);

                // mTmpMatrix will be used in multi thread.
                synchronized (mMatrixLock){
                    System.arraycopy(mSensorMatrix, 0, mTmpMatrix, 0, 16);
                }
                getParams().glHandler.post(updateSensorRunnable);
                break;
        }
    }
}
 

@Override public void onSensorChanged(SensorEvent event) {
  if (event.sensor.getType() != Sensor.TYPE_ROTATION_VECTOR || !mBeerView.isMax()) {
    return;
  }

  float[] rotationMatrix = new float[9];
  SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values);

  float[] adjustedRotationMatrix = new float[9];
  SensorManager.remapCoordinateSystem(rotationMatrix, SensorManager.AXIS_X, SensorManager.AXIS_Z,
      adjustedRotationMatrix);

  float[] orientation = new float[3];
  SensorManager.getOrientation(adjustedRotationMatrix, orientation);

  float roll = orientation[2] * -57;

  if (roll < ROLL_LIMIT && roll > -ROLL_LIMIT) {
    mBeerView.drawGlass(-roll);
    mBeerView.drawGlassFroth(-roll, 1);
    mOldRoll = -roll;
  } else {
    mBeerView.drawGlass(mOldRoll);
    mBeerView.drawGlassFroth(mOldRoll, 1);
  }
}
 

@Override
public void onSensorChanged(final SensorEvent event) {
    if (isOn && event.accuracy != 0){
        if (getParams().mSensorListener != null){
            getParams().mSensorListener.onSensorChanged(event);
        }

        int type = event.sensor.getType();
        switch (type){
            case Sensor.TYPE_ROTATION_VECTOR:
                // post
                VRUtil.sensorRotationVector2Matrix(event, windowManager.getDefaultDisplay().getRotation(), mSensorMatrix);

                // mTmpMatrix will be used in multi thread.
                synchronized (mMatrixLock){
                    System.arraycopy(mSensorMatrix, 0, mTmpMatrix, 0, 16);
                }
                getParams().glHandler.post(updateSensorRunnable);
                break;
        }
    }
}
 

@Override
public void onSensorChanged(SensorEvent event) {
    if( event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR ){
        // calculate th rotation matrix
        SensorManager.getRotationMatrixFromVector(rMat, event.values);
        // get the azimuth value (orientation[0]) in degree

        newAzimuth = (int) ((((( Math.toDegrees( SensorManager.getOrientation( rMat, orientation )[0] ) + 360 ) % 360) -
                      ( Math.toDegrees( SensorManager.getOrientation( rMat, orientation )[2] ))) +360) % 360);

        //dont react to changes smaller than the filter value
        if (Math.abs(mAzimuth - newAzimuth) < mFilter) {
            return;
        }

        getReactApplicationContext()
                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                .emit("headingUpdated", (int) newAzimuth);

        mAzimuth = newAzimuth;
    }
}
 

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        // Get the current heading from the sensor, then notify the listeners of the
        // change.
        SensorManager.getRotationMatrixFromVector(mRotationMatrix, event.values);
        SensorManager.remapCoordinateSystem(mRotationMatrix, SensorManager.AXIS_X,
                SensorManager.AXIS_Z, mRotationMatrix);
        SensorManager.getOrientation(mRotationMatrix, mOrientation);

        // Store the pitch (used to display a message indicating that the user's head
        // angle is too steep to produce reliable results.
        mPitch = (float) Math.toDegrees(mOrientation[1]);

        // Convert the heading (which is relative to magnetic north) to one that is
        // relative to true north, using the user's current location to compute this.
        float magneticHeading = (float) Math.toDegrees(mOrientation[0]);
        mHeading = MathUtils.mod(computeTrueNorth(magneticHeading), 360.0f)
                - ARM_DISPLACEMENT_DEGREES;

        notifyOrientationChanged();
    }
}
 

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        if (event.values.length > 4) {
            float[] truncatedRotationVector = new float[4];
            System.arraycopy(event.values, 0, truncatedRotationVector, 0, 4);
            update(truncatedRotationVector);
        } else {
            update(event.values);
        }
    }
}
 

@Override
public void onSensorChanged(SensorEvent event) {
    // that we received the proper event
    if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        // convert the rotation-vector to a 4x4 matrix. the matrix
        // is interpreted by Open GL as the inverse of the
        // rotation-vector, which is what we want.
        SensorManager.getRotationMatrixFromVector(currentOrientationRotationMatrix, event.values);
    }
}
 

@Override
public void onSensorChanged(SensorEvent event) {
    // Check that we received the proper sensor event
    if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        logOrientation(event);
    }
}
 

@Override
public void onSensorChanged(SensorEvent event) {

    switch (event.sensor.getType()) {
        case Sensor.TYPE_GAME_ROTATION_VECTOR:
        case Sensor.TYPE_ROTATION_VECTOR:
            processSensorOrientation(event.values);
            break;
        default:
            Log.e("DeviceOrientation", "Sensor event type not supported");
            break;
    }
}
 

private void loadSensorData(SensorEvent event) {
    int sensorType = event.sensor.getType();
    if (sensorType == Sensor.TYPE_ACCELEROMETER) mGravity = event.values;
    if (sensorType == Sensor.TYPE_MAGNETIC_FIELD) mGeomagnetic = event.values;
    if (sensorType == Sensor.TYPE_ROTATION_VECTOR) mRotationVector = event.values;
}
 

@Override
public void onSensorChanged(SensorEvent sensorEvent) {
    if (sensorEvent.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        float[] rotationMatrixFromVector = new float[16];
        float[] rotationMatrix = new float[16];
        getRotationMatrixFromVector(rotationMatrixFromVector, sensorEvent.values);
        final int screenRotation = this.getWindowManager().getDefaultDisplay()
                .getRotation();

        switch (screenRotation) {
            case ROTATION_90:
                remapCoordinateSystem(rotationMatrixFromVector,
                        AXIS_Y,
                        AXIS_MINUS_X, rotationMatrix);
                break;
            case ROTATION_270:
                remapCoordinateSystem(rotationMatrixFromVector,
                        AXIS_MINUS_Y,
                        AXIS_X, rotationMatrix);
                break;
            case ROTATION_180:
                remapCoordinateSystem(rotationMatrixFromVector,
                        AXIS_MINUS_X, AXIS_MINUS_Y,
                        rotationMatrix);
                break;
            default:
                remapCoordinateSystem(rotationMatrixFromVector,
                        AXIS_X, AXIS_Y,
                        rotationMatrix);
                break;
        }

        float[] projectionMatrix = arCamera.getProjectionMatrix();
        float[] rotatedProjectionMatrix = new float[16];
        Matrix.multiplyMM(rotatedProjectionMatrix, 0, projectionMatrix, 0, rotationMatrix, 0);
        this.arOverlayView.updateRotatedProjectionMatrix(rotatedProjectionMatrix);

        //Heading
        float[] orientation = new float[3];
        getOrientation(rotatedProjectionMatrix, orientation);
        double bearing = Math.toDegrees(orientation[0]) + declination;
        tvBearing.setText(String.format("Bearing: %s", bearing));
    }
}
 

private void populateTypeField( int type ) {
	if( type == 0 || mTypeRow == null || mType == null )
		return;

	String typeName;

	switch( type ) {
		case Sensor.TYPE_ACCELEROMETER: {
			typeName = "Accelerometer";
			break;
		}
		case Sensor.TYPE_AMBIENT_TEMPERATURE: {
			typeName = "Ambient Temperature";
			break;
		}
		case Sensor.TYPE_GAME_ROTATION_VECTOR: {
			typeName = "Game Rotation Vector";
			break;
		}
		case Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR: {
			typeName = "Geomagnetic Rotation Vector";
			break;
		}
		case Sensor.TYPE_GRAVITY: {
			typeName = "Gravity";
			break;
		}
		case Sensor.TYPE_GYROSCOPE: {
			typeName = "Gyroscope";
			break;
		}
		case Sensor.TYPE_GYROSCOPE_UNCALIBRATED: {
			typeName = "Uncalibrated Gyroscope";
			break;
		}
		case Sensor.TYPE_LIGHT: {
			typeName = "Light";
			break;
		}
		case Sensor.TYPE_LINEAR_ACCELERATION: {
			typeName = "Linear Acceleration";
			break;
		}
		case Sensor.TYPE_MAGNETIC_FIELD: {
			typeName = "Magnetic Field";
			break;
		}
		case Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED: {
			typeName = "Uncalibrated Magnetic Field";
			break;
		}
		case Sensor.TYPE_PRESSURE: {
			typeName = "Pressure";
			break;
		}
		case Sensor.TYPE_PROXIMITY: {
			typeName = "Proximity";
			break;
		}
		case Sensor.TYPE_RELATIVE_HUMIDITY: {
			typeName = "Relative Humidity";
			break;
		}
		case Sensor.TYPE_ROTATION_VECTOR: {
			typeName = "Rotation Vector";
			break;
		}
		case Sensor.TYPE_SIGNIFICANT_MOTION: {
			typeName = "Significant Motion";
			break;
		}
		case Sensor.TYPE_STEP_COUNTER: {
			typeName = "Step Counter";
			break;
		}
		case Sensor.TYPE_STEP_DETECTOR: {
			typeName = "Step Detector";
			break;
		}
		default: {
			typeName = "Other";
		}
	}
	mType.setText( typeName );
	mTypeRow.setVisibility( View.VISIBLE );
}
 

@SuppressLint("InlinedApi")  // There is a check in STEP_DETECTOR and STEP_COUNTER
private static int getSensorType(SKSensorModuleType sensorType) throws SKException{

    switch (sensorType) {

        case ACCELEROMETER:
            return Sensor.TYPE_ACCELEROMETER;

        case GRAVITY:
            return Sensor.TYPE_GRAVITY;

        case LINEAR_ACCELERATION:
            return Sensor.TYPE_LINEAR_ACCELERATION;

        case GYROSCOPE:
            return Sensor.TYPE_GYROSCOPE;

        case ROTATION:
            return Sensor.TYPE_ROTATION_VECTOR;

        case MAGNETOMETER:
            return Sensor.TYPE_MAGNETIC_FIELD;

        case AMBIENT_TEMPERATURE:
            return Sensor.TYPE_AMBIENT_TEMPERATURE;

        case STEP_DETECTOR:

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                return Sensor.TYPE_STEP_DETECTOR;
            }
            else
            {
                throw new SKException(TAG, "STEP_DETECTOR requires Android KitKat or greater.", SKExceptionErrorCode.UNKNOWN_ERROR);
            }

        case STEP_COUNTER:

            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                return Sensor.TYPE_STEP_COUNTER;
            }
            else
            {
                throw new SKException(TAG, "STEP_COUNTER requires Android KitKat or greater.", SKExceptionErrorCode.UNKNOWN_ERROR);
            }

        case LIGHT:
            return Sensor.TYPE_LIGHT;

        case LOCATION:
        case ACTIVITY:
        case BATTERY:
            throw new SKException(TAG, "Not a native SensorModule.", SKExceptionErrorCode.UNKNOWN_ERROR);

        default:
            throw new SKException(TAG, "Unknown SensorModule", SKExceptionErrorCode.UNKNOWN_ERROR);

    }
}
 

public static String[] getLabelsForSensor(Context context, Sensor sensor) {
    String[] labels;
    switch (sensor.getType()) {
        case Sensor.TYPE_ACCELEROMETER:
            labels = context.getResources().getStringArray(R.array.accelerometer_values);
            break;
        case Sensor.TYPE_AMBIENT_TEMPERATURE:
            labels = context.getResources().getStringArray(R.array.ambient_temperature_values);
            break;
        case Sensor.TYPE_GAME_ROTATION_VECTOR:
            labels = context.getResources().getStringArray(R.array.game_rotation_vector_values);
            break;
        case Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR:
            labels = context.getResources().getStringArray(R.array.rotation_vector_values);
            break;
        case Sensor.TYPE_GRAVITY:
            labels = context.getResources().getStringArray(R.array.gravity_values);
            break;
        case Sensor.TYPE_GYROSCOPE:
            labels = context.getResources().getStringArray(R.array.gyroscore_values);
            break;
        case Sensor.TYPE_GYROSCOPE_UNCALIBRATED:
            labels = context.getResources().getStringArray(R.array.gyroscore_uncalibrated_values);
            break;
        case Sensor.TYPE_HEART_RATE:
            labels = context.getResources().getStringArray(R.array.heart_rate_values);
            break;
        case Sensor.TYPE_LIGHT:
            labels = context.getResources().getStringArray(R.array.light_values);
            break;
        case Sensor.TYPE_LINEAR_ACCELERATION:
            labels = context.getResources().getStringArray(R.array.linear_acceleration_values);
            break;
        case Sensor.TYPE_MAGNETIC_FIELD:
            labels = context.getResources().getStringArray(R.array.magnetic_values);
            break;
        case Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED:
            labels = context.getResources().getStringArray(R.array.magnetic_field_uncalibrated_values);
            break;
        case Sensor.TYPE_PRESSURE:
            labels = context.getResources().getStringArray(R.array.pressure_values);
            break;
        case Sensor.TYPE_PROXIMITY:
            labels = context.getResources().getStringArray(R.array.proximity_values);
            break;
        case Sensor.TYPE_RELATIVE_HUMIDITY:
            labels = context.getResources().getStringArray(R.array.relative_humidity_values);
            break;
        case Sensor.TYPE_ROTATION_VECTOR:
            labels = context.getResources().getStringArray(R.array.rotation_vector_values);
            break;
        case Sensor.TYPE_STEP_COUNTER:
            labels = context.getResources().getStringArray(R.array.step_counter_values);
            break;
        default:
            labels = new String[]{};
    }
    return labels;
}
 

@Nullable
public static String getHumanStringType(Sensor sensor) {
    switch (sensor.getType()) {
        case Sensor.TYPE_ACCELEROMETER:
            return "Accelerometer";

        case Sensor.TYPE_AMBIENT_TEMPERATURE:
            return "Ambient Temperature";

        case Sensor.TYPE_GAME_ROTATION_VECTOR:
            return "Game Rotation Vector";

        case Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR:
            return "Geomagnetic Rotation Vector";

        case Sensor.TYPE_GRAVITY:
            return "Gravity";

        case Sensor.TYPE_GYROSCOPE:
            return "Gyroscope";

        case Sensor.TYPE_GYROSCOPE_UNCALIBRATED:
            return "Gyroscope (Uncalibrated)";

        case Sensor.TYPE_HEART_RATE:
            return "Heart Rate";

        case Sensor.TYPE_LIGHT:
            return "Light";

        case Sensor.TYPE_LINEAR_ACCELERATION:
            return "Linear Acceleration";

        case Sensor.TYPE_MAGNETIC_FIELD:
            return "Magnetic Field";

        case Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED:
            return "Magnetic Field (Uncalibrated)";

        case Sensor.TYPE_PRESSURE:
            return "Pressure";

        case Sensor.TYPE_PROXIMITY:
            return "Proximity";

        case Sensor.TYPE_RELATIVE_HUMIDITY:
            return "Relative Humidity";

        case Sensor.TYPE_ROTATION_VECTOR:
            return "Rotation Vector";

        case Sensor.TYPE_SIGNIFICANT_MOTION:
            return "Significant Motion";

        case Sensor.TYPE_STEP_COUNTER:
            return "Step Counter";

        case Sensor.TYPE_STEP_DETECTOR:
            return "Step Detector";

        case Sensor.TYPE_ORIENTATION:
            return "Orientation";

        case Sensor.TYPE_TEMPERATURE:
            return "Temperature";
    }
    return null;
}
 

public static String getDescription(Sensor sensor) {
    switch (sensor.getType()) {
        case Sensor.TYPE_ACCELEROMETER:
            return "Measures the acceleration force in m/s² that is applied to a device on all three physical axes (x, y, and z), including the force of gravity.";

        case Sensor.TYPE_AMBIENT_TEMPERATURE:
            return "Measures the ambient room temperature in degrees Celsius (°C).";

        case Sensor.TYPE_GRAVITY:
            return "Measures the force of gravity in m/s² that is applied to a device on all three physical axes (x, y, z).";

        case Sensor.TYPE_GYROSCOPE:
            return "Measures a device's rate of rotation in rad/s around each of the three physical axes (x, y, and z).";

        case Sensor.TYPE_HEART_RATE:
            return "Measures heart rate.";

        case Sensor.TYPE_LIGHT:
            return "Measures the ambient light level (illumination) in lx.";

        case Sensor.TYPE_LINEAR_ACCELERATION:
            return "Measures the acceleration force in m/s² that is applied to a device on all three physical axes (x, y, and z), excluding the force of gravity.";

        case Sensor.TYPE_MAGNETIC_FIELD:
            return "Measures the ambient geomagnetic field for all three physical axes (x, y, z) in μT.";

        case Sensor.TYPE_PRESSURE:
            return "Measures the ambient air pressure in hPa or mbar.";

        case Sensor.TYPE_PROXIMITY:
            return "Measures the proximity of an object in cm relative to the view screen of a device. This sensor is typically used to determine whether a handset is being held up to a person's ear.";

        case Sensor.TYPE_RELATIVE_HUMIDITY:
            return "Measures the relative ambient humidity in percent (%).";

        case Sensor.TYPE_ROTATION_VECTOR:
            return "Measures the orientation of a device by providing the three elements of the device's rotation vector.";

        case Sensor.TYPE_ORIENTATION:
            return "Measures degrees of rotation that a device makes around all three physical axes (x, y, z). ";

        case Sensor.TYPE_TEMPERATURE:
            return "Measures the temperature of the device in degrees Celsius (°C). ";

        default:
            return "Information about this sensor is unavailable.";
    }
}
 

@Override
public void start() throws SensorException
{
    // we call stop() to cleanup just in case we weren't properly stopped
    stop();        
    Context androidContext = config.androidContext;
    
    // create data interfaces for sensors
    this.sensorManager = (SensorManager)androidContext.getSystemService(Context.SENSOR_SERVICE);
    List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
    for (Sensor sensor: deviceSensors)
    {
        log.debug("Detected sensor " + sensor.getName());
        
        switch (sensor.getType())
        {
            case Sensor.TYPE_ACCELEROMETER:
                if (config.activateAccelerometer)
                    useSensor(new AndroidAcceleroOutput(this, sensorManager, sensor), sensor);                        
                break;
                
            case Sensor.TYPE_GYROSCOPE:
                if (config.activateGyrometer)
                    useSensor(new AndroidGyroOutput(this, sensorManager, sensor), sensor);
                break;
            
            case Sensor.TYPE_MAGNETIC_FIELD:
                if (config.activateMagnetometer)
                    useSensor(new AndroidMagnetoOutput(this, sensorManager, sensor), sensor);
                break;
                
            case Sensor.TYPE_ROTATION_VECTOR:
                if (config.activateOrientationQuat)
                    useSensor(new AndroidOrientationQuatOutput(this, sensorManager, sensor), sensor);
                if (config.activateOrientationEuler)
                    useSensor(new AndroidOrientationEulerOutput(this, sensorManager, sensor), sensor);
                break;
        }
    }
    
    // create data interfaces for location providers
    if (androidContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_LOCATION))
    {
        this.locationManager = (LocationManager)androidContext.getSystemService(Context.LOCATION_SERVICE);
        
        List<String> locProviders = locationManager.getAllProviders();
        for (String provName: locProviders)
        {
            log.debug("Detected location provider " + provName);
            LocationProvider locProvider = locationManager.getProvider(provName);
            
            // keep only GPS for now
            if ( (locProvider.requiresSatellite() && config.activateGpsLocation) ||
                 (locProvider.requiresNetwork() && config.activateNetworkLocation))
                useLocationProvider(new AndroidLocationOutput(this, locationManager, locProvider), locProvider);
        }
    }
    
    // create data interfaces for cameras
    if (androidContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA))
        createCameraOutputs(androidContext);
    
    // init all outputs
    for (ISensorDataInterface o: this.getAllOutputs().values())
        ((IAndroidOutput)o).init();
    
    // update sensorml description
    updateSensorDescription();
}
 

@Override
public void onSensorChanged(SensorEvent event) {
    switch (event.sensor.getType()) {
        case Sensor.TYPE_ROTATION_VECTOR:
            SensorManager.getQuaternionFromVector(latestQuaternion, event.values);
            if (!haveRotVecData) {
                initialiseDefaultFilters(SMOOTHING_FACTOR_HIGH_ACC);
            }
            haveRotVecData = true;
            break;
        case Sensor.TYPE_GRAVITY:
            if (haveRotVecData) {
                // rotation vector sensor data is better
                sensorManager.unregisterListener(this,
                        sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY));
                break;
            }
            System.arraycopy(event.values, 0, latestAccelerations, 0, 3);
            haveGravData = true;
            break;
        case Sensor.TYPE_ACCELEROMETER:
            if (haveGravData || haveRotVecData) {
                // rotation vector / gravity sensor data is better!
                // let's not listen to the accelerometer anymore
                sensorManager.unregisterListener(this,
                        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER));
                break;
            }
            System.arraycopy(event.values, 0, latestAccelerations, 0, 3);
            haveAccelData = true;
            break;
        case Sensor.TYPE_MAGNETIC_FIELD:
            if (haveRotVecData) {
                // rotation vector sensor data is better
                sensorManager.unregisterListener(this,
                        sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD));
                break;
            }
            System.arraycopy(event.values, 0, latestMagFields, 0, 3);
            haveMagData = true;
            break;
    }

    if (haveDataNecessaryToComputeOrientation()) {
        computeOrientation();
    }
}
 

@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
    if (sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
        Log.i(TAG, "Rotation sensor accuracy changed to: " + accuracy);
    }
}