下面列出了怎么用android.hardware.Sensor的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public void onCreate() {
super.onCreate();
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
prefs.edit().remove(SettingsFragment.PREF_LAST_STEP_COUNT).apply();
SensorManager sm = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Sensor stepCounter = sm.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
if (stepCounter == null)
Log.w(TAG, "No hardware stepcounter available");
else {
Log.w(TAG, "Registering step counter listener");
sm.registerListener(mStepCounterListener, stepCounter, SensorManager.SENSOR_DELAY_NORMAL);
}
}
private UserSensor getUserSensor() {
if (mUserSensor == null) {
mUserSensor = new UserSensor.Builder()
.setType(Sensor.TYPE_LIGHT)
.setName(DRIVER_NAME)
.setVendor(DRIVER_VENDOR)
.setVersion(DRIVER_VERSION)
.setMaxRange(DRIVER_MAX_RANGE)
.setPower(DRIVER_POWER)
.setMinDelay(DRIVER_XG_MIN_DELAY_US)
.setMaxDelay(DRIVER_XG_MAX_DELAY_US)
.setUuid(UUID.randomUUID())
.setDriver(this)
.build();
}
return mUserSensor;
}
@Override
public final void onSensorChanged(SensorEvent event) {
int sensorType = event.sensor.getType();
if (sensorType == Sensor.TYPE_ACCELEROMETER) {
mSensorData[kSensorType_Accelerometer].values = event.values;
updateOrientation(); // orientation depends on Accelerometer and Magnetometer
mControllerListAdapter.notifyDataSetChanged();
} else if (sensorType == Sensor.TYPE_GYROSCOPE) {
mSensorData[kSensorType_Gyroscope].values = event.values;
mControllerListAdapter.notifyDataSetChanged();
} else if (sensorType == Sensor.TYPE_MAGNETIC_FIELD) {
mSensorData[kSensorType_Magnetometer].values = event.values;
updateOrientation(); // orientation depends on Accelerometer and Magnetometer
mControllerListAdapter.notifyDataSetChanged();
}
}
@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);
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
setContentView(R.layout.main);
view = findViewById(R.id.textView);
view.setBackgroundColor(Color.GREEN);
sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
sensorManager.registerListener(this,
sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_NORMAL);
lastUpdate = System.currentTimeMillis();
}
@Override
protected void onStart() {
super.onStart();
// Register the BMP280 temperature sensor
Sensor temperature = mSensorManager
.getDynamicSensorList(Sensor.TYPE_AMBIENT_TEMPERATURE).get(0);
mSensorManager.registerListener(mSensorEventListener, temperature,
SensorManager.SENSOR_DELAY_NORMAL);
// Register the BMP280 pressure sensor
Sensor pressure = mSensorManager
.getDynamicSensorList(Sensor.TYPE_PRESSURE).get(0);
mSensorManager.registerListener(mSensorEventListener, pressure,
SensorManager.SENSOR_DELAY_NORMAL);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_mei_firefly);
mMobikeView = findViewById(R.id.mo_bike);
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
addViews();
mMobikeView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mMobikeView.onRandomChanged();
}
});
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_PROXIMITY) {
proximity_events++;
if (proximity_events < 20)
Log.d(TAG, "Sensor: " + event.values[0] + " " + mProximity.getMaximumRange());
if (event.values[0] <= (Math.min(mProximity.getMaximumRange() / 2, 10))) {
proximity = true; // near
} else {
proximity = false; // far
}
if (proximity_events < 20) Log.d(TAG, "Proxmity set to: " + proximity);
}
}
public void onSensorChanged(SensorEvent sensorEvent) {
if (sensorEvent.sensor.getType() == Sensor.TYPE_HEART_RATE) {
if (sensorEvent.accuracy == SensorManager.SENSOR_STATUS_NO_CONTACT ||
sensorEvent.accuracy == SensorManager.SENSOR_STATUS_UNRELIABLE) {
Log.d(TAG, "Heart Rate Monitor not in contact or unreliable");
} else {
float currentHeartRate = sensorEvent.values[0];
Log.d(TAG, "Heart Rate: " + currentHeartRate);
}
}
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_LIGHT) {
//光线强度
float lux = event.values[0];
Log.e(TAG, "光线传感器得到的光线强度-->" + lux);
}
}
private void probeOrientation() {
StringBuilder sb = new StringBuilder();
SensorManager mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
List<Sensor> sensorList = mSensorManager.getSensorList(Sensor.TYPE_ORIENTATION);
for (Sensor s : sensorList) {
sb.append(s.getName() + ":" + s.toString() + "\n");
}
output.setText(sb.toString());
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
float xy_angle = event.values[0]; //Плоскость XY
float xz_angle = event.values[1]; //Плоскость XZ
float zy_angle = event.values[2]; //Плоскость ZY
float sum = (xy_angle + xz_angle + zy_angle);
if (mPosition == 0) {
mPosition = sum;
}
float vibrationLevel = Math.abs(mPosition - sum);
if (vibrationLevel > 0.5) {
L.d("Diff: " + vibrationLevel);
}
if (vibrationLevel > type.getShakeValue()) {
L.i("Shake detected! Diff: " + vibrationLevel);
long time = System.currentTimeMillis();
if (alarmTime == 0 || (time - alarmTime) > TIMEOUT) {
if (service != null) {
service.sendMessageToAll(context.getString(R.string.alarm_shake));
}
alarmTime = time;
}
}
mPosition = sum;
} else {
L.i(String.format("eventName: %s, eventType: %s", event.sensor.getName(), event.sensor.getType()));
for (int i = 0; i < event.values.length; i++) {
L.i(String.format("value %s: %s", i, event.values[i]));
}
}
}
/**
* Pauses the sensors to save battery life if the sensors are not needed.
* Used to pause sensors when the activity pauses
*/
public void pauseSensors() {
for (Entry entry: sensors) {
if (entry.getKey() != Sensor.TYPE_ORIENTATION) {
unRegisterListener(entry.getKey());
}
}
}
/**accelerometer methods*/
protected boolean activateAccelerometer()
{
if(mSensorManager != null && mSensorManager.registerListener(this, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), (int)(mAccelerometerInterval * 1000.0f)))
return true;
PLLog.debug("PLView::activateAccelerometer", "Accelerometer sensor is not available on the device!");
return false;
}
public void stepCounterOnClick(View view) {
if (checkSensorAvailability(Sensor.TYPE_STEP_DETECTOR)) {
currentSensor = Sensor.TYPE_STEP_DETECTOR;
} else {
textView.setText("Step Counter Sensor not available");
}
}
@Override
public void onCreate() {
super.onCreate();
mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Sensor mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
mSensorManager.registerListener(mSensorListener, mSensor, SensorManager.SENSOR_DELAY_FASTEST);
}
public AccelerometerHandler(AndroidGame game) {
this.game = game;
defaultOrientation = getDeviceDefaultOrientation();
deviceOrientationManager = new DeviceOrientationManager();
SensorManager manager = (SensorManager) game.getSystemService(Context.SENSOR_SERVICE);
if (manager.getSensorList(Sensor.TYPE_ACCELEROMETER).size() > 0) {
Sensor accelerometer = manager.getSensorList(Sensor.TYPE_ACCELEROMETER).get(0);
manager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_FASTEST);
getUpdates = true;
}
deviceOrientationManager.enable();
}
@Override
public boolean test() throws Throwable {
SensorManager sensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
try {
Sensor heartRateSensor = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);
sensorManager.registerListener(SENSOR_EVENT_LISTENER, heartRateSensor, 3);
sensorManager.unregisterListener(SENSOR_EVENT_LISTENER, heartRateSensor);
} catch (Throwable e) {
PackageManager packageManager = mContext.getPackageManager();
return !packageManager.hasSystemFeature(PackageManager.FEATURE_SENSOR_STEP_DETECTOR);
}
return true;
}
@SmallTest
public void testWhenOnAltitudeChangedWithSoemthingOtherThanPressureDoesNotCallCallback() throws InterruptedException {
float[] data = new float[] {1.0f};
_listener.sensorChanged(Sensor.TYPE_ACCELEROMETER, data);
_latch.await(2000, TimeUnit.MILLISECONDS);
assertEquals(1,_latch.getCount());
}
public void start(){
mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
mLastAccelerometerSet = false;
mLastMagnetometerSet = false;
mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_NORMAL);
mSensorManager.registerListener(this, mMagnetometer, SensorManager.SENSOR_DELAY_NORMAL);
}
@Override
public void onSensorChanged(SensorEvent sensorEvent) {
final float alpha= 0.97f;
synchronized (this){
if (sensorEvent.sensor.getType ()==Sensor.TYPE_ACCELEROMETER){
mGravity[0]= alpha*mGravity[0]+(1-alpha)*sensorEvent.values[0];
mGravity[1]= alpha*mGravity[1]+(1-alpha)*sensorEvent.values[1];
mGravity[2]= alpha*mGravity[2]+(1-alpha)*sensorEvent.values[2];
}
if (sensorEvent.sensor.getType ()==Sensor.TYPE_MAGNETIC_FIELD){
mGeomagnetic[0]= alpha*mGeomagnetic[0]+(1-alpha)*sensorEvent.values[0];
mGeomagnetic[1]= alpha*mGeomagnetic[1]+(1-alpha)*sensorEvent.values[1];
mGeomagnetic[2]= alpha*mGeomagnetic[2]+(1-alpha)*sensorEvent.values[2];
}
float R[] =new float[9];
float I[] =new float[9];
boolean success = SensorManager.getRotationMatrix ( R,I,mGravity,mGeomagnetic );
if (success) {
float orientation[] = new float[3];
SensorManager.getOrientation ( R,orientation );
azimuth =(float)Math.toDegrees ( orientation[0] );
azimuth = (azimuth+360)%360;
//
Animation anim =new RotateAnimation ( -correctAzimuth,-azimuth, Animation.RELATIVE_TO_SELF,0.5f
,Animation.RELATIVE_TO_SELF,0.5f);
correctAzimuth = azimuth;
anim.setDuration ( 500 );
anim.setRepeatCount ( 0 );
anim.setFillAfter ( true );
imageView.startAnimation ( anim );
}
}
}
/**
* Start listening for shakes.
*/
public void start(SensorManager manager) {
Assertions.assertNotNull(manager);
Sensor accelerometer = manager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
if (accelerometer != null) {
mSensorManager = manager;
mLastTimestamp = -1;
mCurrentIndex = 0;
mMagnitudes = new double[MAX_SAMPLES];
mTimestamps = new long[MAX_SAMPLES];
mSensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_UI);
mNumShakes = 0;
mLastShakeTimestamp = 0;
}
}
/**
*
*
* <pre>
* Time = 01 .. 10 .. 15 .. 20 .. 50
* Sensor A/Listener A = [............]
* Sensor B/Listener B = [............]
* </pre>
*/
@Test
public void test_attribution_snapshot() {
Sensor sensorB = mock(Sensor.class);
SensorEventListener listenerB = mock(SensorEventListener.class);
when(sensorB.getType()).thenReturn(2);
when(sensorB.getPower()).thenReturn(100.0f);
ShadowSystemClock.setElapsedRealtime(1);
collector.register(listener, sensor);
ShadowSystemClock.setElapsedRealtime(10);
collector.register(listenerB, sensorB);
ShadowSystemClock.setElapsedRealtime(15);
collector.unregister(listener, null);
ShadowSystemClock.setElapsedRealtime(20);
collector.unregister(listenerB, null);
ShadowSystemClock.setElapsedRealtime(50);
metrics.isAttributionEnabled = true;
assertThat(collector.getSnapshot(metrics)).isTrue();
assertThat(metrics.total.activeTimeMs).isEqualTo(14 + 10);
assertThat(metrics.sensorConsumption.size()).isEqualTo(2);
assertThat(metrics.sensorConsumption.get(1337).activeTimeMs).isEqualTo(14);
assertThat(metrics.sensorConsumption.get(1337).powerMah)
.isEqualTo((14.0 * (double) sensor.getPower()) / 3600 / 1000);
assertThat(metrics.sensorConsumption.get(2).activeTimeMs).isEqualTo(10);
assertThat(metrics.sensorConsumption.get(2).powerMah)
.isEqualTo((10.0 * (double) sensorB.getPower()) / 3600 / 1000);
}
private void sensorAction(int action, AndroidSensorWrapper androidSensorWrapper) {
SensorEventListener sensorEventListener = androidSensorWrapper.getSensorEventListener();
Sensor sensor = sensorManager.getDefaultSensor(androidSensorWrapper.getAndroidSensorType());
//if (action == REGISTER && androidSensorWrapper.isEnabled()){
if (action == REGISTER){
sensorManager.registerListener(sensorEventListener, sensor, SensorManager.SENSOR_DELAY_NORMAL);
androidSensorWrapper.setRegistered(true);
}else if (action == UNREGISTER){
//}else if (action == UNREGISTER
// && androidSensorWrapper.isEnabled() && androidSensorWrapper.isRegistered()){
sensorManager.unregisterListener(sensorEventListener, sensor);
androidSensorWrapper.setRegistered(false);
}
}
/**
* 判断是否存在光传感器来判断是否为模拟器
* 部分真机也不存在温度和压力传感器。其余传感器模拟器也存在。
*
* @return false为模拟器
*/
private boolean hasLightSensor(Context context) {
SensorManager sensorManager = (SensorManager) context.getSystemService(SENSOR_SERVICE);
Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); //光线传感器
if (null == sensor) return false;
else return true;
}
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
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
@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);
}
}
@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}