下面列出了android.hardware.Sensor#TYPE_AMBIENT_TEMPERATURE 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
updateSensorData(latestSampledData.accelerate, event);
} else if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
updateSensorData(latestSampledData.gyroscope, event);
} else if (event.sensor.getType() == Sensor.TYPE_GRAVITY) {
updateSensorData(latestSampledData.gravity, event);
} else if (event.sensor.getType() == Sensor.TYPE_LIGHT) {
latestSampledData.light = event.values[0];
} else if (event.sensor.getType() == Sensor.TYPE_PRESSURE) {
latestSampledData.pressure = event.values[0];
} else if (event.sensor.getType() == Sensor.TYPE_AMBIENT_TEMPERATURE) {
latestSampledData.temperature = event.values[0];
} else if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
updateSensorData(latestSampledData.magnetic, event);
} else if (event.sensor.getType() == Sensor.TYPE_GAME_ROTATION_VECTOR) {
updateSensorData(latestSampledData.game_rotation_vector, event);
}
}
@Override
public void onSensorChanged(SensorEvent event) {
final float value = event.values[0];
if (event.sensor.getType() == Sensor.TYPE_AMBIENT_TEMPERATURE) {
updateTemperatureDisplay(value);
} else if (event.sensor.getType() == Sensor.TYPE_PRESSURE) {
updateBarometerDisplay(value);
}
}
@Override
public void onDynamicSensorConnected(Sensor sensor) {
if (sensor.getType() == Sensor.TYPE_AMBIENT_TEMPERATURE) {
Log.i(TAG, "Temperature sensor connected");
mSensorManager.registerListener(TemperatureActivity.this,
sensor, SensorManager.SENSOR_DELAY_NORMAL);
}
}
public void ambientTempSensorOnClick(View view) {
if (checkSensorAvailability(Sensor.TYPE_AMBIENT_TEMPERATURE)) {
currentSensor = Sensor.TYPE_AMBIENT_TEMPERATURE;
} else {
textView.setText("Ambient Temperature Sensor not available");
}
}
@SuppressWarnings("deprecation")
private boolean isRestricted(XParam param, int type) throws Throwable {
if (type == Sensor.TYPE_ALL)
return false;
else if (type == Sensor.TYPE_ACCELEROMETER || type == Sensor.TYPE_LINEAR_ACCELERATION) {
if (isRestricted(param, "acceleration"))
return true;
} else if (type == Sensor.TYPE_GRAVITY) {
if (isRestricted(param, "gravity"))
return true;
} else if (type == Sensor.TYPE_RELATIVE_HUMIDITY) {
if (isRestricted(param, "humidity"))
return true;
} else if (type == Sensor.TYPE_LIGHT) {
if (isRestricted(param, "light"))
return true;
} else if (type == Sensor.TYPE_MAGNETIC_FIELD || type == Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED) {
if (isRestricted(param, "magnetic"))
return true;
} else if (type == Sensor.TYPE_SIGNIFICANT_MOTION) {
if (isRestricted(param, "motion"))
return true;
} else if (type == Sensor.TYPE_ORIENTATION || type == Sensor.TYPE_GYROSCOPE
|| type == Sensor.TYPE_GYROSCOPE_UNCALIBRATED) {
if (isRestricted(param, "orientation"))
return true;
} else if (type == Sensor.TYPE_PRESSURE) {
if (isRestricted(param, "pressure"))
return true;
} else if (type == Sensor.TYPE_PROXIMITY) {
if (isRestricted(param, "proximity"))
return true;
} else if (type == Sensor.TYPE_GAME_ROTATION_VECTOR || type == Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR
|| type == Sensor.TYPE_ROTATION_VECTOR) {
if (isRestricted(param, "rotation"))
return true;
} else if (type == Sensor.TYPE_TEMPERATURE || type == Sensor.TYPE_AMBIENT_TEMPERATURE) {
if (isRestricted(param, "temperature"))
return true;
} else if (type == Sensor.TYPE_STEP_COUNTER || type == Sensor.TYPE_STEP_DETECTOR) {
if (isRestricted(param, "step"))
return true;
} else if (type == Sensor.TYPE_HEART_RATE) {
if (isRestricted(param, "heartrate"))
return true;
} else if (type == 22) {
// 22 = TYPE_TILT_DETECTOR
// Do nothing
} else if (type == 23 || type == 24 || type == 25) {
// 23 = TYPE_WAKE_GESTURE
// 24 = TYPE_GLANCE_GESTURE
// 25 = TYPE_PICK_UP_GESTURE
// 23/24 This sensor is expected to only be used by the system ui
// 25 Expected to be used internally for always on display
} else
Util.log(this, Log.WARN, "Unknown sensor type=" + type);
return false;
}
AmbientTemperatureUpdatesProvider(int sensorDelay) {
super(Sensor.TYPE_AMBIENT_TEMPERATURE, sensorDelay);
}
public TemperatureMonitor(Context ctx, SensorManager sensorManager, ServerConnection serverConnection) {
super(ctx, sensorManager, serverConnection, ctx.getString(R.string.pref_temperature), "temperature", Sensor.TYPE_AMBIENT_TEMPERATURE);
}
public PAmbientTemperature(AppRunner appRunner) {
super(appRunner);
type = Sensor.TYPE_AMBIENT_TEMPERATURE;
}
private boolean isTemperature(int sensorType) {
return sensorType == Sensor.TYPE_AMBIENT_TEMPERATURE || isNexus6pThermometer(sensorType);
}
@Override
public void onSensorChanged(SensorEvent event) {
if (event.sensor.getType() == currentSensor) {
if (currentSensor == Sensor.TYPE_LIGHT) {
float valueZ = event.values[0];
textView.setText("Brightness " + valueZ);
} else if (currentSensor == Sensor.TYPE_PROXIMITY) {
float distance = event.values[0];
textView.setText("Proximity " + distance);
} else if (currentSensor == Sensor.TYPE_STEP_DETECTOR) {
float steps = event.values[0];
textView.setText("Steps : " + steps);
} else if (currentSensor == Sensor.TYPE_ACCELEROMETER) {
float x = event.values[0];
float y = event.values[1];
float z = event.values[2];
long curTime = System.currentTimeMillis();
if ((curTime - lastUpdate) > 100) {
long diffTime = (curTime - lastUpdate);
lastUpdate = curTime;
float speed = Math.abs(x + y + z - last_x - last_y - last_z) / diffTime * 10000;
if (speed > SHAKE_THRESHOLD) {
Toast.makeText(getApplicationContext(), "Your phone just shook", Toast.LENGTH_LONG).show();
}
last_x = x;
last_y = y;
last_z = z;
}
} else if (currentSensor == Sensor.TYPE_GYROSCOPE) {
if (event.values[2] > 0.5f) {
textView.setText("Anti Clock");
} else if (event.values[2] < -0.5f) {
textView.setText("Clock");
}
} else if (currentSensor == Sensor.TYPE_AMBIENT_TEMPERATURE) {
textView.setText("Ambient Temp in Celsius :" + event.values[0]);
}
}
}
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.";
}
}
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);
}
}
/**
* Called by {@link MainActivity} when a sensor's reading changes. Updates sensor display.
*/
public void onSensorChanged(SensorEvent event) {
switch (event.sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
accX.setText(String.format("%." + mAccSensorRes + "f", event.values[0]));
accY.setText(String.format("%." + mAccSensorRes + "f", event.values[1]));
accZ.setText(String.format("%." + mAccSensorRes + "f", event.values[2]));
accTotal.setText(String.format("%." + mAccSensorRes + "f", Math.sqrt(Math.pow(event.values[0], 2) + Math.pow(event.values[1], 2) + Math.pow(event.values[2], 2))));
accStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_ORIENTATION:
orAzimuth.setText(String.format("%.0f%s", event.values[0], getString(R.string.unit_degree)));
orAziText.setText(MainActivity.formatOrientation(this.getContext(), event.values[0]));
orPitch.setText(String.format("%.0f%s", event.values[1], getString(R.string.unit_degree)));
orRoll.setText(String.format("%.0f%s", event.values[2], getString(R.string.unit_degree)));
orStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_GYROSCOPE:
rotX.setText(String.format("%." + mGyroSensorRes + "f", event.values[0]));
rotY.setText(String.format("%." + mGyroSensorRes + "f", event.values[1]));
rotZ.setText(String.format("%." + mGyroSensorRes + "f", event.values[2]));
rotTotal.setText(String.format("%." + mGyroSensorRes + "f", Math.sqrt(Math.pow(event.values[0], 2) + Math.pow(event.values[1], 2) + Math.pow(event.values[2], 2))));
rotStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_MAGNETIC_FIELD:
magX.setText(String.format("%." + mMagSensorRes + "f", event.values[0]));
magY.setText(String.format("%." + mMagSensorRes + "f", event.values[1]));
magZ.setText(String.format("%." + mMagSensorRes + "f", event.values[2]));
magTotal.setText(String.format("%." + mMagSensorRes + "f", Math.sqrt(Math.pow(event.values[0], 2) + Math.pow(event.values[1], 2) + Math.pow(event.values[2], 2))));
magStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_LIGHT:
light.setText(String.format("%." + mLightSensorRes + "f", event.values[0]));
lightStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_PROXIMITY:
proximity.setText(String.format("%." + mProximitySensorRes + "f", event.values[0]));
proximityStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_PRESSURE:
metPressure.setText(String.format("%." + mPressureSensorRes + "f", event.values[0]));
pressureStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_RELATIVE_HUMIDITY:
metHumid.setText(String.format("%." + mHumiditySensorRes + "f", event.values[0]));
humidStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
case Sensor.TYPE_AMBIENT_TEMPERATURE:
metTemp.setText(String.format("%." + mTempSensorRes + "f", event.values[0]));
tempStatus.setTextColor(getResources().getColor(accuracyToColor(event.accuracy)));
break;
}
}
/**
* Called when a sensor's reading changes. Updates sensor display and rotates sky plot according
* to bearing.
*/
public void onSensorChanged(SensorEvent event) {
//to enforce sensor rate
boolean isRateElapsed = false;
switch (event.sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
isRateElapsed = (event.timestamp / 1000) - mAccLast >= iSensorRate;
// if Z acceleration is greater than X/Y combined, lock rotation, else unlock
if (Math.pow(event.values[2], 2) > Math.pow(event.values[0], 2) + Math.pow(event.values[1], 2)) {
// workaround (SCREEN_ORIENTATION_LOCK is unsupported on API < 18)
if (isWideScreen)
setRequestedOrientation(OR_FROM_ROT_WIDE[this.getWindowManager().getDefaultDisplay().getRotation()]);
else
setRequestedOrientation(OR_FROM_ROT_TALL[this.getWindowManager().getDefaultDisplay().getRotation()]);
} else {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
}
break;
case Sensor.TYPE_ORIENTATION:
isRateElapsed = (event.timestamp / 1000) - mOrLast >= iSensorRate;
break;
case Sensor.TYPE_GYROSCOPE:
isRateElapsed = (event.timestamp / 1000) - mGyroLast >= iSensorRate;
break;
case Sensor.TYPE_MAGNETIC_FIELD:
isRateElapsed = (event.timestamp / 1000) - mMagLast >= iSensorRate;
break;
case Sensor.TYPE_LIGHT:
isRateElapsed = (event.timestamp / 1000) - mLightLast >= iSensorRate;
break;
case Sensor.TYPE_PROXIMITY:
isRateElapsed = (event.timestamp / 1000) - mProximityLast >= iSensorRate;
break;
case Sensor.TYPE_PRESSURE:
isRateElapsed = (event.timestamp / 1000) - mPressureLast >= iSensorRate;
break;
case Sensor.TYPE_RELATIVE_HUMIDITY:
isRateElapsed = (event.timestamp / 1000) - mHumidityLast >= iSensorRate;
break;
case Sensor.TYPE_AMBIENT_TEMPERATURE:
isRateElapsed = (event.timestamp / 1000) - mTempLast >= iSensorRate;
break;
}
if (!isRateElapsed)
return;
switch (event.sensor.getType()) {
case Sensor.TYPE_ACCELEROMETER:
mAccLast = event.timestamp / 1000;
break;
case Sensor.TYPE_ORIENTATION:
mOrLast = event.timestamp / 1000;
break;
case Sensor.TYPE_GYROSCOPE:
mGyroLast = event.timestamp / 1000;
break;
case Sensor.TYPE_MAGNETIC_FIELD:
mMagLast = event.timestamp / 1000;
break;
case Sensor.TYPE_LIGHT:
mLightLast = event.timestamp / 1000;
break;
case Sensor.TYPE_PROXIMITY:
mProximityLast = event.timestamp / 1000;
break;
case Sensor.TYPE_PRESSURE:
mPressureLast = event.timestamp / 1000;
break;
case Sensor.TYPE_RELATIVE_HUMIDITY:
mHumidityLast = event.timestamp / 1000;
break;
case Sensor.TYPE_AMBIENT_TEMPERATURE:
mTempLast = event.timestamp / 1000;
break;
}
if (sensorSectionFragment != null) {
sensorSectionFragment.onSensorChanged(event);
}
if (gpsSectionFragment != null) {
gpsSectionFragment.onSensorChanged(event);
}
}
@SuppressWarnings({ "unchecked", "deprecation" })
public EnvironmentalSucker(Context context) {
super(context);
setSucker(this);
sm = (SensorManager)context.getApplicationContext().getSystemService(Context.SENSOR_SERVICE);
availableSensors = sm.getSensorList(Sensor.TYPE_ALL);
for(Sensor s : availableSensors) {
switch(s.getType()) {
case Sensor.TYPE_AMBIENT_TEMPERATURE:
sm.registerListener(this, s, SensorManager.SENSOR_DELAY_NORMAL);
break;
case Sensor.TYPE_RELATIVE_HUMIDITY:
sm.registerListener(this, s, SensorManager.SENSOR_DELAY_NORMAL);
break;
case Sensor.TYPE_PRESSURE:
sm.registerListener(this, s, SensorManager.SENSOR_DELAY_NORMAL);
break;
case Sensor.TYPE_LIGHT:
sm.registerListener(this, s, SensorManager.SENSOR_DELAY_NORMAL);
break;
case Sensor.TYPE_TEMPERATURE:
sm.registerListener(this, s, SensorManager.SENSOR_DELAY_NORMAL);
break;
}
}
setTask(new TimerTask() {
@Override
public void run() {
if(currentAmbientTemp != null)
sendToBuffer(currentAmbientTemp);
if(currentDeviceTemp != null)
sendToBuffer(currentDeviceTemp);
if(currentHumidity != null)
sendToBuffer(currentHumidity);
if(currentPressure != null)
sendToBuffer(currentPressure);
if(currentLight != null)
sendToBuffer(currentLight);
}
});
getTimer().schedule(getTask(), 0, Environment.LOG_RATE);
}
/**
*
Sensor Sensor event data Units of measure Data description
TYPE_AMBIENT_TEMPERATURE event.values[0] °C Ambient air temperature.
TYPE_LIGHT event.values[0] lx Illuminance.
TYPE_PRESSURE event.values[0] hPa or mbar Ambient air pressure.
TYPE_RELATIVE_HUMIDITY event.values[0] % Ambient relative humidity.
TYPE_TEMPERATURE event.values[0] °C Device temperature.1
*/
@SuppressWarnings("deprecation")
@Override
public void onSensorChanged(SensorEvent event) {
synchronized(this) {
if(getIsRunning()) {
ILogPack sVals = new ILogPack();
try {
switch(event.sensor.getType()) {
case Sensor.TYPE_AMBIENT_TEMPERATURE:
sVals.put(Environment.Keys.AMBIENT_TEMP_CELSIUS, event.values[0]);
currentAmbientTemp = sVals;
break;
case Sensor.TYPE_TEMPERATURE:
sVals.put(Environment.Keys.DEVICE_TEMP_CELSIUS, event.values[0]);
currentDeviceTemp = sVals;
break;
case Sensor.TYPE_RELATIVE_HUMIDITY:
sVals.put(Environment.Keys.HUMIDITY_PERC,event.values[0]);
currentHumidity = sVals;
break;
case Sensor.TYPE_PRESSURE:
sVals.put(Environment.Keys.PRESSURE_MBAR, event.values[0]);
//TODO we need to get real local sea level pressure here from a dynamic source
//as the default value doesn't cut it
float altitudeFromPressure = SensorManager.getAltitude(mPressureSeaLevel, event.values[0]);
sVals.put(Environment.Keys.PRESSURE_ALTITUDE, altitudeFromPressure);
currentPressure = sVals;
break;
case Sensor.TYPE_LIGHT:
sVals.put(Environment.Keys.LIGHT_METER_VALUE, event.values[0]);
currentLight = sVals;
break;
}
} catch(JSONException e) {}
}
}
}
/**
* Creates a new Thermometer component.
*
* @param container ignored (because this is a non-visible component)
*/
public Thermometer(ComponentContainer container) {
super(container.$form(), Sensor.TYPE_AMBIENT_TEMPERATURE);
}