android.hardware.SensorManager Java Examples

private void getOrientation(final float[] rotateMatrix, final float[] result) {

			switch (mRotation) {
			case Surface.ROTATION_0:
				SensorManager.getOrientation(rotateMatrix, result);
				return;
			case Surface.ROTATION_90:
				SensorManager.remapCoordinateSystem(
					rotateMatrix, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, outR);
				break;
			case Surface.ROTATION_180:
				SensorManager.remapCoordinateSystem(
					rotateMatrix, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, outR2);
				SensorManager.remapCoordinateSystem(
					outR2, SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, outR);
				break;
			case Surface.ROTATION_270:
				SensorManager.remapCoordinateSystem(
					outR, SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_MINUS_X, outR);
				break;
			}
			SensorManager.getOrientation(outR, result);
		}
 

@Override
public void onStart(@NonNull SensorManager sensorManager) {
    if (DEBUG) Log.d(TAG, "Starting proximity sensor...");

    mHistory.clear();
    mHistory.add(new Event(false, getTimeNow()));

    Config.getInstance().registerListener(this);
    updateWave2WakeProgram();

    // Ignore pocket program's start delay,
    // so app can act just after it has started.
    mFirstChange = true;
    mPocketProgram.dataArray[0].timeMin = 0;

    Sensor proximitySensor = sensorManager.getDefaultSensor(getType());
    sensorManager.registerListener(this, proximitySensor, SensorManager.SENSOR_DELAY_NORMAL);

    mMaximumRange = proximitySensor.getMaximumRange();
    sAttached = true;
}
 

private float[] getGyroscopeValues(float timeDifference) {
    float[] angularRates = new float[] {0.0F, 0.0F, 0.0F};
    float[] rotationMatrix = new float[9];
    float[] gravityRot = new float[3];
    float[] angleChange = new float[3];

    SensorManager.getRotationMatrix(rotationMatrix, null, this.accelerometerValues, this.magneticValues);
    gravityRot[0] = GRAVITY[0] * rotationMatrix[0] + GRAVITY[1] * rotationMatrix[3] + GRAVITY[2] * rotationMatrix[6];
    gravityRot[1] = GRAVITY[0] * rotationMatrix[1] + GRAVITY[1] * rotationMatrix[4] + GRAVITY[2] * rotationMatrix[7];
    gravityRot[2] = GRAVITY[0] * rotationMatrix[2] + GRAVITY[1] * rotationMatrix[5] + GRAVITY[2] * rotationMatrix[8];
    SensorManager.getRotationMatrix(rotationMatrix, null, gravityRot, this.magneticValues);

    SensorManager.getAngleChange(angleChange, rotationMatrix, this.prevRotationMatrix);
    angularRates[0] = -(angleChange[1]) / timeDifference;
    angularRates[1] = (angleChange[2]) / timeDifference;
    angularRates[2] = (angleChange[0]) / timeDifference;

    this.prevRotationMatrix = rotationMatrix;
    return angularRates;
}
 

/**
*
   */
  @Override
  protected boolean connect() throws SSJFatalException
  {
      manager = (SensorManager) SSJApplication.getAppContext().getSystemService(Context.SENSOR_SERVICE);

      boolean ok = true;
      for(SensorListener l : listeners)
      {
          Sensor s = manager.getDefaultSensor(l.getType().getType());
          if (s == null)
          {
              Log.e(l.getType().getName() + " not found on device");
              ok = false;
          }
          else
          {
              ok &= manager.registerListener(l, s, options.sensorDelay.get());
          }
      }

      return ok;
  }
 

@Override
public void onSensorChanged(SensorEvent event) {
	if (!getUpdates) {
		SensorManager manager = (SensorManager) game.getSystemService(Context.SENSOR_SERVICE);
		if (manager.getSensorList(Sensor.TYPE_ACCELEROMETER).size() > 0) {
			manager.unregisterListener(this);
		}			
		return;
	}
	switch (event.sensor.getType()) {
		case Sensor.TYPE_ACCELEROMETER:
			for (int i = 0; i < 3; i++) {
				accelValues[i] = event.values[i];
			}
			break;
	}

	float roll  = (float) Math.atan2(accelValues[0], accelValues[2]);
	float pitch = (float) Math.atan2(accelValues[1], accelValues[2]);

	accelValues[2] = -roll;
	accelValues[1] = -pitch;
	accelValues[0] = 0;
	adjustAccelOrientation(accelValues);
}
 

@Override
public void onSensorChanged(SensorEvent event) {

    // we received a sensor event. it is a good practice to check
    // that we received the proper event
    if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
        magnitudeValues = event.values.clone();
    } else if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
        accelerometerValues = event.values.clone();
    }

    if (magnitudeValues != null && accelerometerValues != null) {
        float[] i = new float[16];

        // Fuse accelerometer with compass
        SensorManager.getRotationMatrix(currentOrientationRotationMatrix.matrix, i, accelerometerValues,
                magnitudeValues);
        // Transform rotation matrix to quaternion
        currentOrientationQuaternion.setRowMajor(currentOrientationRotationMatrix.matrix);
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Language
    mLang = Utils.getCurrentLanguage();
    if (mLang > -1) {
        Utils.changeLanguage(this, mLang);
    }


    //set Theme
    if(Settings.isNightMode){
        this.setTheme(R.style.NightTheme);
    }else{
        this.setTheme(R.style.DayTheme);
    }

    setContentView(R.layout.activity_reading_details);
    initData();

    mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

}
 

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {

        long curTime = System.currentTimeMillis();
        // if a shake in last X seconds ignore.
        if (lastShake != 0 && (curTime - lastShake) < IGNORE_EVENTS_AFTER_SHAKE) return;

        float x = event.values[SensorManager.DATA_X];
        float y = event.values[SensorManager.DATA_Y];
        float z = event.values[SensorManager.DATA_Z];
        if (last_x != 0 && last_y != 0 && last_z != 0 && (last_x != x || last_y != y || last_z != z)) {
            DataPoint dp = new DataPoint(last_x-x, last_y-y, last_z-z, curTime);
            //Log.i("XYZ",Float.toString(dp.x)+"   "+Float.toString(dp.y)+"   "+Float.toString(dp.z)+"   ");
            dataPoints.add(dp);

            if ((curTime - lastUpdate) > SHAKE_CHECK_THRESHOLD) {
                lastUpdate = curTime;
                checkForShake();
            }
        }
        last_x = x;
        last_y = y;
        last_z = z;
    }
}
 

/**
 * register the default sensor of specific type
 * @param type sensor id
 */
private void registerSensor(int type){
    Sensor defaultSensor = sensorManager.getDefaultSensor(type);

    //set normalization factor
    if (type == Sensor.TYPE_ACCELEROMETER){
        gestureDataHolder.allowSensorDataCollection(type);

        //normalize to range form -2 to 2
        gestureDataHolder.setNormalizationFactor(type, 2 / defaultSensor.getMaximumRange());
    }

    if (type == Sensor.TYPE_GYROSCOPE){
        gestureDataHolder.allowSensorDataCollection(type);

        //from rad to deg
        gestureDataHolder.setNormalizationFactor(type, 57.2958);
    }

    sensorManager.registerListener(this, defaultSensor, SensorManager.SENSOR_DELAY_GAME);
    //sensorManager.registerListener(this, defaultSensor, SensorManager.SENSOR_DELAY_FASTEST);
}
 

protected void update(float[] vectors) {
	int worldAxisX = SensorManager.AXIS_X;
	int worldAxisZ = SensorManager.AXIS_Z;

	float[] rotationMatrix = new float[9];
	float[] adjustedRotationMatrix = new float[9];
	float[] orientation = new float[3];

	SensorManager.getRotationMatrixFromVector(rotationMatrix, vectors);
	SensorManager.remapCoordinateSystem(rotationMatrix, worldAxisX, worldAxisZ, adjustedRotationMatrix);
	SensorManager.getOrientation(adjustedRotationMatrix, orientation);

	float roll = orientation[2] * FROM_RADS_TO_DEGS;

	if (roll > -45 && roll < 45) {
		setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
		Log.d(LOG_TAG, "Requesting undefined");
	}
	Log.d(LOG_TAG, "Roll: " + roll);
}
 

@Override
public void enableTrackScreenOrientation(boolean enable) {
    try {
        if (enable) {
            if (mOrientationDetector == null) {
                mOrientationDetector = new SensorsDataScreenOrientationDetector(mContext, SensorManager.SENSOR_DELAY_NORMAL);
            }
            mOrientationDetector.enable();
        } else {
            if (mOrientationDetector != null) {
                mOrientationDetector.disable();
                mOrientationDetector = null;
            }
        }
    } catch (Exception e) {
        com.sensorsdata.analytics.android.sdk.SALog.printStackTrace(e);
    }
}
 

/**
 * @return <code>true</code> when the sensor was successfully enabled, <code>false</code> otherwise.
 */
public boolean enableAccelerationSensor(final Context pContext, final IAccelerationListener pAccelerationListener, final AccelerationSensorOptions pAccelerationSensorOptions) {
	final SensorManager sensorManager = (SensorManager) pContext.getSystemService(Context.SENSOR_SERVICE);
	if (this.isSensorSupported(sensorManager, Sensor.TYPE_ACCELEROMETER)) {
		this.mAccelerationListener = pAccelerationListener;

		this.initDefaultDisplay(pContext);

		if (this.mAccelerationData == null) {
			this.mAccelerationData = new AccelerationData();
		}

		this.registerSelfAsSensorListener(sensorManager, Sensor.TYPE_ACCELEROMETER, pAccelerationSensorOptions.getSensorDelay());

		return true;
	} else {
		return false;
	}
}
 

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    ProximitySensor = (TextView)findViewById(R.id.proximitySensor);
    ProximityMax = (TextView)findViewById(R.id.proximityMax);
    ProximityReading = (TextView)findViewById(R.id.proximityReading);
    // Now in the SensorActivity we access the device sensor using SensorManager, an instance of this class is got by calling getSystemService(SENSOR_SERVICE) . We implement the class with theSensorEventListener interface to override its methods to do actions on sensor value change.
    mySensorManager = (SensorManager)getSystemService(
      Context.SENSOR_SERVICE);
    myProximitySensor = mySensorManager.getDefaultSensor(
      Sensor.TYPE_PROXIMITY);
    
    if (myProximitySensor == null){
     ProximitySensor.setText("No Proximity Sensor!"); 
    }else{
     ProximitySensor.setText(myProximitySensor.getName());
     ProximityMax.setText("Maximum Range: "
       + String.valueOf(myProximitySensor.getMaximumRange()));
     mySensorManager.registerListener(proximitySensorEventListener,
       myProximitySensor,
       SensorManager.SENSOR_DELAY_NORMAL);
    }
}
 

public static Sensor getSensorFromUniqueSensorKey(Context context, String key) {
    String[] data = key.split(Pattern.quote(SENSOR_SEPARATOR)); //Regex, man. Regex.
    if (data.length >= 4) {
        try {
            String name = data[0];
            String vendor = data[1];
            int version = Integer.parseInt(data[2]);
            int type = Integer.parseInt(data[3]);
            SensorManager manager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
            for (Sensor sensor : manager.getSensorList(type)) {
                if (sensor.getName().equals(name)
                        && sensor.getVendor().equals(vendor)
                        && sensor.getVersion() == version) {
                    return sensor;
                }
            }
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Unable to get unique sensor from key.");
        }
    } else {
        Log.e("SensorUtil", "Unable to parse \"" + key + "\" as Sensor data.");
    }
    return null;
}
 

private void setTorch() {
    switch (mMode) {
        case MODE_AUTO:
            if (sensorManager != null) {
                sensorManager.registerListener(this,
                        sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT),
                        SensorManager.SENSOR_DELAY_NORMAL);
            }
            break;
        case MODE_OPEN:
            if (sensorManager != null) {
                sensorManager.unregisterListener(this);
            }
            if (mCallBack != null)
                mCallBack.onChange(true);
            break;
        case MODE_CLOSE:
            if (sensorManager != null) {
                sensorManager.unregisterListener(this);
            }
            if (mCallBack != null)
                mCallBack.onChange(false);
            break;
    }
}
 

SensorEventListener createSensorEventListener(final EventChannel.EventSink events) {
  return new SensorEventListener() {
    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
      if (mLastAccuracy != accuracy) {
        mLastAccuracy = accuracy;
      }
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
      if (mLastAccuracy == SensorManager.SENSOR_STATUS_UNRELIABLE) {
        return;
      }

      updateOrientation(event.values, events);
    }
  };
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_compass);
  mCompassView = findViewById(R.id.compassView);

  mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
  WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);

  Display display = wm.getDefaultDisplay();
  mScreenRotation = display.getRotation();

  mNewestValues = new float[] {0, 0, 0};

  Timer updateTimer = new Timer("compassUpdate");
  updateTimer.scheduleAtFixedRate(new TimerTask() {
    public void run() {
      updateGUI();
    }
  }, 0, 1000/60);
}
 

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.main);

    mXValueView = findViewById(R.id.x_value_view);
    mYValueView = findViewById(R.id.y_value_view);
    mZValueView = findViewById(R.id.z_value_view);

    mXGravityView = findViewById(R.id.x_lowpass_view);
    mYGravityView = findViewById(R.id.y_lowpass_view);
    mZGravityView = findViewById(R.id.z_lowpass_view);

    mXAccelView = findViewById(R.id.x_highpass_view);
    mYAccelView = findViewById(R.id.y_highpass_view);
    mZAccelView = findViewById(R.id.z_highpass_view);

    // Get reference to SensorManager
    mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

    if (null != mSensorManager) {
        // Get reference to Accelerometer
        mAccelerometer = mSensorManager
                .getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        if (null == mAccelerometer) finish();

        mLastUpdate = System.currentTimeMillis();
    }
}
 

private void uninstallConnectionSensor() {
    if (mIsSensorRegistered && CommonUtils.isMainProcess(mContext) && VisualAgent.isInDebug()) {
        final SensorManager sensorManager = (SensorManager) mContext.getSystemService
                (Context.SENSOR_SERVICE);
        sensorManager.unregisterListener(mFlipGesture);
        mFlipGesture.reset();
        mIsSensorRegistered = false;
    }
}
 

public void dispose() {
	if (deviceOrientationManager != null) {
		deviceOrientationManager.disable();
	}
	SensorManager manager = (SensorManager) game.getSystemService(Context.SENSOR_SERVICE);
	if (manager.getSensorList(Sensor.TYPE_ACCELEROMETER).size() > 0) {
		manager.unregisterListener(this);			
	}
	getUpdates = false;
}
 

/**
 * Unregisters the sensor listener if it is registered.
 */
private void unregisterListeners() {
    // BEGIN_INCLUDE(unregister)
    SensorManager sensorManager =
            (SensorManager) getActivity().getSystemService(Activity.SENSOR_SERVICE);
    sensorManager.unregisterListener(mListener);
    Log.i(TAG, "Sensor listener unregistered.");

    // END_INCLUDE(unregister)
}
 

public void start() {
	// 获得传感器管理器
	sensorManager = (SensorManager) context
			.getSystemService(Context.SENSOR_SERVICE);
	if (sensorManager != null) {
		// 获得重力传感器
		sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
	}
	// 注册
	if (sensor != null) {
		sensorManager.registerListener(this, sensor,
				SensorManager.SENSOR_DELAY_GAME);
	}
}
 

public void disableAccelerometerListening()
{
   // get the SensorManager
   SensorManager sensorManager = 
      (SensorManager) getActivity().getSystemService(
         Context.SENSOR_SERVICE);

   // stop listening for accelerometer events
   sensorManager.unregisterListener(sensorEventListener, 
      sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER));         
}
 

/**
 * Computes the latest rotation, remaps it according to the current {@link #screenRotation},
 * and stores it in {@link #rotationMatrix}.
 * <p>
 * Should only be called if {@link #haveDataNecessaryToComputeOrientation()} returns true and
 * {@link #haveRotVecData} is false, else result may be undefined.
 *
 * @return true if rotation was retrieved and recalculated, false otherwise.
 */
private boolean computeRotationMatrix() {
    if (SensorManager.getRotationMatrix(rotationMatrixTemp, null, latestAccelerations, latestMagFields)) {
        switch (screenRotation) {
            case Surface.ROTATION_0:
                SensorManager.remapCoordinateSystem(rotationMatrixTemp,
                        SensorManager.AXIS_X, SensorManager.AXIS_Y, rotationMatrix);
                break;
            case Surface.ROTATION_90:
                //noinspection SuspiciousNameCombination
                SensorManager.remapCoordinateSystem(rotationMatrixTemp,
                        SensorManager.AXIS_Y, SensorManager.AXIS_MINUS_X, rotationMatrix);
                break;
            case Surface.ROTATION_180:
                SensorManager.remapCoordinateSystem(rotationMatrixTemp,
                        SensorManager.AXIS_MINUS_X, SensorManager.AXIS_MINUS_Y, rotationMatrix);
                break;
            case Surface.ROTATION_270:
                //noinspection SuspiciousNameCombination
                SensorManager.remapCoordinateSystem(rotationMatrixTemp,
                        SensorManager.AXIS_MINUS_Y, SensorManager.AXIS_X, rotationMatrix);
                break;
        }
        return true;
    }
    return false;
}
 

public void onCreate(final Bundle icicle) {
    super.onCreate(icicle);

    Bundle extras = getIntent().getExtras();
    SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
    orientationSensor = new OrientationSensor(sensorManager, null);
    orientationSensor.register(this, SensorManager.SENSOR_DELAY_NORMAL);
    noteId = extras.getLong(LibraryConstants.DATABASE_ID);
    lon = extras.getDouble(LibraryConstants.LONGITUDE);
    lat = extras.getDouble(LibraryConstants.LATITUDE);
    elevation = extras.getDouble(LibraryConstants.ELEVATION);


    final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
    boolean warningAlreadyShown = preferences.getBoolean(LibraryConstants.PREFS_KEY_CAMERA_WARNING_SHOWN, false);
    if (warningAlreadyShown) {
        doTakePicture(icicle);
    } else {
        GPDialogs.infoDialog(this, getString(R.string.first_camera_open_warning), new Runnable() {
            @Override
            public void run() {
                doTakePicture(icicle);
                SharedPreferences.Editor editor = preferences.edit();
                editor.putBoolean(LibraryConstants.PREFS_KEY_CAMERA_WARNING_SHOWN, true);
                editor.apply();
            }
        });
    }
}
 

/**
 * Builds the array of supported {@link ActiveModeSensor sensors}.
 *
 * @return The array of supported {@link ActiveModeSensor sensors}.
 * @see ActiveModeSensor
 */
@NonNull
public static ActiveModeSensor[] buildAvailableSensorsList(@NonNull Context context) {
    SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    ActiveModeSensor[] sensors = new ActiveModeSensor[]{ // all available sensors
            AccelerometerSensor.getInstance(),
            GyroscopeSensor.getInstance(),
            ProximitySensor.getInstance()
    };

    // Count the number of supported sensors, and
    // mark unsupported.
    int count = sensors.length;
    boolean[] supportList = new boolean[sensors.length];
    for (int i = 0; i < sensors.length; i++) {
        supportList[i] = sensors[i].isSupported(sensorManager);
        if (!supportList[i]) {
            count--;
        }
    }

    // Create the list of proven sensors.
    ActiveModeSensor[] sensorsSupported = new ActiveModeSensor[count];
    for (int i = 0, j = 0; i < sensors.length; i++) {
        if (supportList[i]) {
            sensorsSupported[j++] = sensors[i];
        }
    }

    return sensorsSupported;
}
 

void start(CameraManager cameraManager) {
  this.cameraManager = cameraManager;
  SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
  if (FrontLightMode.readPref(sharedPrefs) == FrontLightMode.AUTO) {
    SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    if (lightSensor != null) {
      sensorManager.registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
    }
  }
}
 

@Override
protected void onResume() {
	super.onResume();
	sensorManager.registerListener(sensorListener,
			SensorManager.SENSOR_ORIENTATION,
			SensorManager.SENSOR_DELAY_FASTEST);
}
 

@Override
public IBinder onBind(Intent intent) {
	mSensorManager.registerListener(mSensorEventListener,
			mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
			SensorManager.SENSOR_DELAY_GAME);
	return new PlayBinder();
}
 

void start(CameraManager cameraManager) {
    this.cameraManager = cameraManager;
    SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(context);
    if (FrontLightMode.readPref(sharedPrefs) == FrontLightMode.AUTO) {
        SensorManager sensorManager = (SensorManager) context
                .getSystemService(Context.SENSOR_SERVICE);
        lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
        if (lightSensor != null) {
            sensorManager
                    .registerListener(this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
        }
    }
}