public Android.App.Dialog Show(Action <Sensor> onSensorCreated)
{
var adb = new IONAlertDialog(context);
adb.SetTitle(Resource.String.sensor_create_manual_entry);
adb.SetView(content);
var ret = adb.Show();
content.FindViewById(Resource.Id.cancel).Click += (sender, e) => {
ret.Dismiss();
};
content.FindViewById(Resource.Id.ok_done).Click += (sender, e) => {
double d;
if (!double.TryParse(measurement.Text, out d))
{
Toast.MakeText(context, Resource.String.please_enter_valid_number, ToastLength.Long).Show();
return;
}
var sensor = new ManualSensor(sensorType, sensorType == ESensorType.Vacuum);
sensor.measurement = sensorUnit.OfScalar(d);
sensor.name = name.Text;
onSensorCreated(sensor);
ret.Dismiss();
};
return(ret);
}
public void hideLHUI()
{
LabelMiddle.Text = undefinedText;
LabelTop.Hidden = true;
Connection.Hidden = true;
DeviceImage.Hidden = true;
LabelBottom.Hidden = true;
LabelSubview.Hidden = true;
subviewTable.Hidden = true;
headingDivider.Hidden = true;
connectionColor.Hidden = true;
subviewHide.Hidden = true;
subviewTable.Source = null;
subviewTable.ReloadData();
subviewTable.Hidden = true;
max = 0;
min = 0;
LabelMiddle.Font = UIFont.FromName("DroidSans", 20f);
if (attachedSensor != null)
{
attachedSensor.topLabel.BackgroundColor = UIColor.Clear;
attachedSensor.topLabel.TextColor = UIColor.Gray;
attachedSensor = null;
}
subviewHide.SetImage(null, UIControlState.Normal);
currentSensor = null;
manualSensor = null;
isManual = false;
}
public ManualSensorParcelable(ManualSensor sensor)
{
sensorType = sensor.type;
isRelative = sensor.isRelative;
unitCode = UnitLookup.GetCode(sensor.unit);
amount = sensor.measurement.amount;
name = sensor.name;
}
// Overridden from SensorParcelable
public override Sensor Get(IION ion)
{
var ret = new ManualSensor(sensorType, isRelative);
ret.name = name;
ret.measurement = UnitLookup.GetUnit(unitCode).OfScalar(amount);
return(ret);
}
private Sensor ReadManualSensor(BinaryReader reader)
{
// Read the actual sensor type
var sensorType = (ESensorType)reader.ReadInt32();
// Read whether or not the sensor is relative
var relative = reader.ReadBoolean();
// Read and determine the unit code
var rawUnit = reader.ReadByte();
// Read the amount of the sensor
var amount = reader.ReadDouble();
// Read the minimum measurement of the sensor
var rawMinUnit = reader.ReadByte();
var rawMinAmount = 0.0;
if (rawMinUnit != 0)
{
rawMinAmount = reader.ReadDouble();
}
// Read the maximum measurement of the sensor
var rawMaxUnit = reader.ReadByte();
var rawMaxAmount = 0.0;
if (rawMaxUnit != 0)
{
rawMaxAmount = reader.ReadDouble();
}
var name = reader.ReadString();
//var ret = new ManualSensor(sensorType, AppState.context.preferences.units.DefaultUnitFor(sensorType).OfScalar(0.0), relative);
var ret = new ManualSensor(AppState.context.manualSensorContainer, sensorType, AppState.context.preferences.units.DefaultUnitFor(sensorType).OfScalar(0.0), relative);
ret.SetMeasurement(UnitLookup.GetUnit(rawUnit).OfScalar(amount));
if (rawMinUnit != 0)
{
ret.minMeasurement = UnitLookup.GetUnit(rawMinUnit).OfScalar(rawMinAmount);
}
if (rawMaxUnit != 0)
{
ret.maxMeasurement = UnitLookup.GetUnit(rawMaxUnit).OfScalar(rawMaxAmount);
}
ret.name = name;
return(ret);
}
// Overridden from IONActivity
protected override void OnResume()
{
base.OnResume();
if (!sensorLocked)
{
var s = new ManualSensor(ESensorType.Pressure, false);
s.unit = ion.preferences.units.pressure;
s.ForceSetMeasurement(ion.preferences.units.pressure.OfScalar(0));
OnSensorChanged(s);
ion.PostToMainDelayed(() => {
slider.ScrollToPressure(s.measurement, true);
}, TimeSpan.FromMilliseconds(500));
}
Refresh();
slider.onScroll += OnSliderScroll;
ion.locationManager.onLocationChanged += OnLocationChanged;
elevation.Text = SensorUtils.ToFormattedString(ion.locationManager.lastKnownLocation.altitude.ConvertTo(ion.preferences.units.length), true);
}
// Overridden from ISensorModel
public Sensor ToSensor(IION ion)
{
var sensorType = (ESensorType)Enum.Parse(typeof(ESensorType), type);
//var ret = new ManualSensor(sensorType, AppState.context.preferences.units.DefaultUnitFor(sensorType).OfScalar(0.0), isRelative);
var ret = new ManualSensor(ion.manualSensorContainer, sensorType, AppState.context.preferences.units.DefaultUnitFor(sensorType).OfScalar(0.0), isRelative);
ret.name = name;
ret.SetMeasurement(UnitLookup.GetUnit(unit).OfScalar(measurement));
if (hasMinMeasurement)
{
ret.minMeasurement = UnitLookup.GetUnit(minUnit).OfScalar(minMeasurement);
}
if (hasMaxMeasurement)
{
ret.maxMeasurement = UnitLookup.GetUnit(maxUnit).OfScalar(maxMeasurement);
}
return(ret);
}
/// <summary>
/// Called when the temperature sensor's measurement is changed.
/// </summary>
/// <param name="sensor">Sensor.</param>
private void OnTemperatureSensorChanged(SensorEvent sensorEvent)
{
var measurement = sensorEvent.sensor.measurement;
if (!editTemperature.IsEditing)
{
editTemperature.Text = SensorUtils.ToFormattedString(measurement);
}
temperatureUnit = measurement.unit;
buttonTemperatureUnit.SetTitle(measurement.unit.ToString(), UIControlState.Normal);
if (pressureSensor == null)
{
pressureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Pressure, new Scalar(pressureUnit, 0.0));
}
var temp = ion.fluidManager.lastUsedFluid.GetSaturatedTemperature(pressureSensor.fluidState, pressureSensor.measurement, ion.locationManager.lastKnownLocation.altitude).ConvertTo(temperatureUnit);
labelSatTempUnit.Text = temp.unit.ToString();
UpdateDelta();
}
public void setUI(ManualSensor lowManual, ManualSensor highManual)
{
pLowHigh.SetTitle(Util.Strings.Analyzer.UNSPECIFIED, UIControlState.Normal);
pLowHigh.BackgroundColor = UIColor.White;
pLowHigh.SetTitleColor(UIColor.Black, UIControlState.Normal);
if (currentSensor == null)
{
pdeviceName.Text = currentSensor.name;
pdeviceImage.Image = UIImage.FromBundle("ic_edit");
pconnectionStatus.Text = "";
pconnection.Image = null;
pconnection.Hidden = true;
pbatteryImage.Image = null;
connectionColor.Hidden = true;
conDisButton.Hidden = true;
if (lowManual != null && manualSensor != null && lowManual == manualSensor)
{
pLowHigh.SetTitle(Util.Strings.Analyzer.LOWSIDE, UIControlState.Normal);
pLowHigh.BackgroundColor = UIColor.Blue;
pLowHigh.Layer.CornerRadius = 6f;
pLowHigh.SetTitleColor(UIColor.White, UIControlState.Normal);
}
else if (highManual != null && manualSensor != null && highManual == manualSensor)
{
pLowHigh.SetTitle(Util.Strings.Analyzer.HIGHSIDE, UIControlState.Normal);
pLowHigh.BackgroundColor = UIColor.Red;
pLowHigh.Layer.CornerRadius = 6f;
pLowHigh.SetTitleColor(UIColor.White, UIControlState.Normal);
}
if (manualSensor.unit != Units.Vacuum.MICRON)
{
pgaugeValue.Text = manualSensor.measurement.amount.ToString("N");
}
else
{
pgaugeValue.Text = manualSensor.measurement.amount.ToString();
}
pvalueType.Text = manualSensor.unit.ToString();
}
else
{
pdeviceName.Text = currentSensor.name;
if (currentSensor.device.isConnected)
{
pconnection.Image = UIImage.FromBundle("ic_bluetooth_connected");
connectionColor.BackgroundColor = UIColor.Green;
pconnectionStatus.Text = "";
if (currentSensor.device.battery > 75)
{
pbatteryImage.Image = UIImage.FromBundle("img_battery_100");
}
else if (currentSensor.device.battery > 50)
{
pbatteryImage.Image = UIImage.FromBundle("img_battery_75");
}
else if (currentSensor.device.battery > 25)
{
pbatteryImage.Image = UIImage.FromBundle("img_battery_50");
}
else if (currentSensor.device.battery > 0)
{
pbatteryImage.Image = UIImage.FromBundle("img_battery_25");
}
else
{
pbatteryImage.Image = UIImage.FromBundle("img_battery_0");
}
}
else
{
pconnection.Image = UIImage.FromBundle("ic_bluetooth_disconnected");
pconnectionStatus.Text = Util.Strings.Device.DISCONNECTED;
pconnectionStatus.TextColor = UIColor.Red;
connectionColor.BackgroundColor = UIColor.Red;
}
if (currentSensor.unit != Units.Vacuum.MICRON)
{
pgaugeValue.Text = currentSensor.measurement.amount.ToString("N");
}
else
{
pgaugeValue.Text = currentSensor.measurement.amount.ToString();
}
pvalueType.Text = currentSensor.unit.ToString();
pconnection.Hidden = false;
connectionColor.Hidden = false;
conDisButton.Hidden = false;
pdeviceImage.Image = DeviceUtil.GetUIImageFromDeviceModel(currentSensor.device.serialNumber.deviceModel);
if (AppState.context.currentAnalyzer.lowSideSensor != null && AppState.context.currentAnalyzer.lowSideSensor == currentSensor)
{
pLowHigh.SetTitle(Util.Strings.Analyzer.LOWSIDE, UIControlState.Normal);
pLowHigh.SetTitleColor(UIColor.White, UIControlState.Normal);
pLowHigh.BackgroundColor = UIColor.Blue;
}
else if (AppState.context.currentAnalyzer.highSideSensor != null && AppState.context.currentAnalyzer.highSideSensor == currentSensor)
{
pLowHigh.SetTitle(Util.Strings.Analyzer.HIGHSIDE, UIControlState.Normal);
pLowHigh.SetTitleColor(UIColor.White, UIControlState.Normal);
pLowHigh.BackgroundColor = UIColor.Red;
}
aView.Hidden = false;
}
}
public ManualSensorEditDialog(Context context, ManualSensor sensor)
{
this.context = context;
this.sensor = sensor;
}
/// <summary>
/// Initializes the temperature widgets for the activity.
/// </summary>
private void InitTemperatureWidgets()
{
var temperatureView = FindViewById(Resource.Id.temperature);
temperatureAddView = temperatureView.FindViewById(Resource.Id.add);
temperatureLockIconView = temperatureAddView.FindViewById <ImageView>(Resource.Id.padlock);
temperatureSensorIconView = temperatureAddView.FindViewById <ImageView>(Resource.Id.icon);
temperatureEntryView = temperatureView.FindViewById <EditText>(Resource.Id.edit);
temperatureUnitView = temperatureView.FindViewById <Button>(Resource.Id.unit);
temperatureClearView = temperatureView.FindViewById <Button>(Resource.Id.clear);
temperatureTextWatcher = new Watcher((editable) => {
var text = editable.ToString();
try {
if (temperatureSensor == null)
{
temperatureSensor = new ManualSensor(ESensorType.Temperature, false);
temperatureSensor.name = GetString(Resource.String.name);
temperatureSensor.unit = temperatureUnit;
}
if (!"".Equals(text))
{
temperatureSensor.measurement = temperatureSensor.unit.OfScalar(double.Parse(text));
}
} catch (System.Exception) {
}
});
temperatureAddView.SetOnClickListener(new ViewClickAction((view) => {
if (!isTemperatureLocked)
{
new GaugeDeviceSensorSelectDialog(this, ion, ESensorType.Temperature, (sensor) => {
temperatureSensor = sensor;
}).Show();
}
}));
temperatureAddView.SetOnLongClickListener(new ViewLongClickAction((view) => {
if (!isTemperatureLocked)
{
temperatureSensor = null;
}
}));
temperatureClearView.SetOnClickListener(new ViewClickAction((view) => {
SetTemperatureInputQuietly("");
}));
temperatureUnitView.Text = temperatureUnit.ToString();
temperatureUnitView.SetOnClickListener(new ViewClickAction((v) => {
var units = temperatureSensor != null ? temperatureSensor.supportedUnits : SensorUtils.DEFAULT_TEMPERATURE_UNITS;
UnitDialog.Create(this, units, (obj, unit) => {
temperatureUnit = unit;
temperatureEntryView.ClearFocus();
if (temperatureSensor != null && temperatureSensor.isEditable)
{
temperatureSensor.unit = unit;
}
}).Show();
}));
temperatureEntryView.AddTextChangedListener(temperatureTextWatcher);
}
/// <summary>
/// Initializes the state and the event handlers for the temperature widgets.
/// </summary>
private void InitTemperatureWidgets()
{
imageTemperatureLock.Image = UIImage.FromBundle("ic_lock");
viewTemperatureTouchArea.AddGestureRecognizer(new UITapGestureRecognizer(() => {
if (!temperatureSensorLocked)
{
var dm = InflateViewController <DeviceManagerViewController>(VC_DEVICE_MANAGER);
dm.displayFilter = new SensorOfTypeFilter(ESensorType.Temperature);
dm.onSensorReturnDelegate = (GaugeDeviceSensor sensor) => {
temperatureUnit = sensor.unit;
temperatureSensor = sensor;
if (ptSlider != null)
{
ptSlider.ptScroller.ScrollEnabled = false;
ptSlider.setOffsetFromSensorMeasurement(new SensorEvent(SensorEvent.EType.Invalidated, sensor));
}
InvalidateViewController();
};
NavigationController.PushViewController(dm, true);
}
}));
viewTemperatureTouchArea.AddGestureRecognizer(new UILongPressGestureRecognizer(() => {
if (!temperatureSensorLocked)
{
temperatureSensor = null;
ClearPressureInput();
ClearTemperatureInput();
if (ptSlider != null)
{
ptSlider.ptScroller.ScrollEnabled = true;
}
}
InvalidateViewController();
}));
editTemperature.ShouldReturn += (textField) => {
textField.ResignFirstResponder();
return(true);
};
editTemperature.AddTarget((object obj, EventArgs args) => {
if (temperatureSensor == null)
{
temperatureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Temperature, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Pressure).OfScalar(0.0), true);
}
SetTemperatureMeasurementFromEditText();
}, UIControlEvent.EditingChanged);
buttonTemperatureUnit.SetBackgroundImage(UIImage.FromBundle("ButtonGold").AsNinePatch(), UIControlState.Normal);
buttonTemperatureUnit.TouchUpInside += (object sender, EventArgs e) => {
if (temperatureSensor == null || temperatureSensor.isEditable)
{
var supportedUnits = temperatureSensor != null ? temperatureSensor.supportedUnits : SensorUtils.DEFAULT_TEMPERATURE_UNITS;
var dialog = CommonDialogs.CreateUnitPicker(Strings.Measure.PICK_UNIT, supportedUnits, (obj, unit) => {
temperatureUnit = unit;
if (ptSlider != null)
{
ptSlider.ptView.tempLookup = unit;
}
if (pressureSensor != null)
{
entryMode = new SensorEntryMode(this, pressureSensor, temperatureUnit, editPressure, editTemperature);
}
else
{
entryMode = new SensorEntryMode(this, temperatureSensor, pressureUnit, editTemperature, editPressure);
}
SetTemperatureMeasurementFromEditText();
if (ptSlider != null)
{
recalculateSlider(pressureUnit, ptSlider.ptView.tempLookup);
}
});
PresentViewController(dialog, true, null);
}
};
}
// Overridden from BaseIONViewController
public override void ViewDidLoad()
{
base.ViewDidLoad();
NavigationItem.Title = Strings.Fluid.PT_CALCULATOR;
NavigationItem.RightBarButtonItem = new UIBarButtonItem(Strings.HELP, UIBarButtonItemStyle.Plain, delegate {
var dialog = new UIAlertView(Strings.HELP, Strings.Fluid.STATE_HELP, null, Strings.OK);
dialog.Show();
});
if (initialSensor == null)
{
InitNavigationBar("ic_nav_pt_chart", false);
backAction = () => {
root.navigation.ToggleMenu();
};
}
ion = AppState.context;
ion.locationManager.onLocationChanged += DeltaOnLocationChanged;
pressureUnit = ion.preferences.units.pressure;
temperatureUnit = ion.preferences.units.temperature;
InitPTChartWidgets();
InitPressureWidgets();
InitTemperatureWidgets();
ClearPressureInput();
ClearTemperatureInput();
if (initialSensor != null)
{
var sensor = initialSensor;
if (ESensorType.Pressure == sensor.type)
{
pressureSensor = sensor;
}
else if (ESensorType.Temperature == sensor.type)
{
temperatureSensor = sensor;
}
else
{
//throw new Exception("Cannot accept sensor that is not a pressure or temperature sensor");
Log.E(this, "Cannot accept sensor that is not a pressure or temperature sensor");
}
}
var manualEdit = false;
var topMark = new UILabel(new CGRect(.5 * View.Bounds.Width - 1, 310, 1, 128 + 20));
if (initialSensor == null)
{
topMark.BackgroundColor = UIColor.Black;
if (temperatureSensor == null)
{
temperatureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Temperature, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Temperature).OfScalar(0.0), true);
}
ptSlider = new SliderView(View, pressureUnit, temperatureUnit, temperatureSensor, entryMode);
((ManualSensor)temperatureSensor).SetMeasurement(ptSlider.ptView.minTemperature.unit.OfScalar(ptSlider.ptView.minTemperature.amount));
editTemperature.Text = temperatureSensor.measurement.amount.ToString("N");
ptSlider.ptScroller.Scrolled += (sender, e) => {
if (!(pressureSensor is GaugeDeviceSensor) && !(temperatureSensor is GaugeDeviceSensor) & manualEdit == false)
{
if (temperatureSensor == null)
{
temperatureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Temperature, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Temperature).OfScalar(0.0), true);
}
setTemperatureValueFromSlider();
}
};
}
editPressure.Started += (sender, e) => {
manualEdit = true;
if (ptSlider != null)
{
ptSlider.ptScroller.ScrollEnabled = false;
}
};
editPressure.EditingChanged += (sender, e) => {
var valid = 0.0;
double.TryParse(editPressure.Text, out valid);
if (ptSlider != null)
{
if (valid >= ptSlider.ptView.minPressure && valid <= ptSlider.ptView.maxPressure.amount)
{
var tempForPressure = ion.fluidManager.lastUsedFluid.GetSaturatedTemperature(pressureSensor.fluidState, new Scalar(pressureUnit, valid), ion.locationManager.lastKnownLocation.altitude).ConvertTo(temperatureUnit).amount;
var manualOffset = (tempForPressure - ptSlider.ptView.minTemperature.amount) * ptSlider.ptView.tempTicks;
ptSlider.ptScroller.SetContentOffset(new CGPoint(manualOffset, 0), false);
}
}
};
editPressure.Ended += (sender, e) => {
manualEdit = false;
if (ptSlider != null)
{
ptSlider.ptScroller.ScrollEnabled = true;
}
};
editTemperature.Started += (sender, e) => {
manualEdit = true;
if (ptSlider != null)
{
ptSlider.ptScroller.ScrollEnabled = false;
}
};
editTemperature.EditingChanged += (sender, e) => {
var valid = 0.0;
double.TryParse(editTemperature.Text, out valid);
if (ptSlider != null)
{
var manualOffset = (valid - ptSlider.ptView.minTemperature.amount) * ptSlider.ptView.tempTicks;
ptSlider.ptScroller.SetContentOffset(new CGPoint(manualOffset, 0), false);
}
};
editTemperature.Ended += (sender, e) => {
manualEdit = false;
if (ptSlider != null)
{
ptSlider.ptScroller.ScrollEnabled = true;
}
};
if (ptSlider != null)
{
View.AddSubview(ptSlider.sliderLabel);
View.AddSubview(ptSlider.ptScroller);
View.AddSubview(topMark);
}
}
// Overridden from BaseIONViewController
public override void ViewDidLoad()
{
base.ViewDidLoad();
if (initialSensor == null)
{
InitNavigationBar("ic_nav_superheat_subcool", false);
backAction = () => {
root.navigation.ToggleMenu();
};
}
ion = AppState.context;
NavigationItem.Title = Strings.Fluid.SUPERHEAT_SUBCOOL;
NavigationItem.RightBarButtonItem = new UIBarButtonItem(Strings.HELP, UIBarButtonItemStyle.Plain, delegate {
var dialog = new UIAlertView(Strings.HELP, Strings.Fluid.STATE_HELP, null, Strings.OK);
dialog.Show();
});
InitializeFluidControlWidgets();
ion.locationManager.onLocationChanged += DeltaOnLocationChanged;
pressureUnit = Units.Pressure.PSIG;
temperatureUnit = Units.Temperature.FAHRENHEIT;
pressureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Pressure, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Pressure).OfScalar(0.0), true);
temperatureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Temperature, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Temperature).OfScalar(0.0), false);
pressureSensor.unit = pressureUnit;
temperatureSensor.unit = temperatureUnit;
buttonPressureUnit.SetBackgroundImage(UIImage.FromBundle("ButtonGold").AsNinePatch(), UIControlState.Normal);
buttonPressureUnit.TouchUpInside += OnPressureUnitChanged;
buttonTemperatureUnit.SetBackgroundImage(UIImage.FromBundle("ButtonGold").AsNinePatch(), UIControlState.Normal);
buttonTemperatureUnit.TouchUpInside += OnTemperatureUnitChanged;
imagePressureLock.Image = UIImage.FromBundle("ic_lock");
imageTemperatureLock.Image = UIImage.FromBundle("ic_lock");
View.AddGestureRecognizer(new UITapGestureRecognizer(() => {
editPressure.ResignFirstResponder();
editTemperature.ResignFirstResponder();
}));
viewPressureTouchArea.AddGestureRecognizer(new UITapGestureRecognizer(() => {
if (!pressureSensorLocked)
{
var dm = InflateViewController <DeviceManagerViewController>(VC_DEVICE_MANAGER);
dm.displayFilter = new SensorOfTypeFilter(ESensorType.Pressure);
dm.onSensorReturnDelegate = (GaugeDeviceSensor sensor) => {
pressureSensor = sensor;
buttonPressureUnit.Enabled = true;
};
NavigationController.PushViewController(dm, true);
}
}));
viewPressureTouchArea.AddGestureRecognizer(new UILongPressGestureRecognizer(() => {
if (!pressureSensorLocked)
{
pressureSensor = null;
buttonPressureUnit.Enabled = false;
ClearPressureInput();
}
}));
editPressure.ShouldReturn += (textField) => {
textField.ResignFirstResponder();
return(true);
};
editTemperature.ShouldReturn += (textField) => {
textField.ResignFirstResponder();
return(true);
};
editPressure.AddTarget((object obj, EventArgs args) => {
try {
if (pressureSensor != null && pressureSensor.isEditable)
{
var measurement = pressureUnit.OfScalar(double.Parse(editPressure.Text));
((ManualSensor)pressureSensor).SetMeasurement(measurement);
}
////if user removes a pressure sensor, they need to be able to create a new manual sensor
if (pressureSensor == null)
{
pressureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Pressure, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Pressure).OfScalar(0.0), true);
var measurement = pressureUnit.OfScalar(double.Parse("0.00"));
((ManualSensor)pressureSensor).SetMeasurement(measurement);
}
buttonPressureUnit.Enabled = true;
} catch (Exception e) {
Log.E(this, "Failed to UpdatePressure: invalid string " + editPressure.Text, e);
}
UpdateDelta();
}, UIControlEvent.EditingChanged);
viewTemperatureTouchArea.AddGestureRecognizer(new UITapGestureRecognizer(() => {
if (!temperatureSensorLocked)
{
var dm = InflateViewController <DeviceManagerViewController>(VC_DEVICE_MANAGER);
dm.displayFilter = new SensorOfTypeFilter(ESensorType.Temperature);
dm.onSensorReturnDelegate = (GaugeDeviceSensor sensor) => {
temperatureSensor = sensor;
buttonTemperatureUnit.Enabled = true;
};
NavigationController.PushViewController(dm, true);
}
}));
viewTemperatureTouchArea.AddGestureRecognizer(new UILongPressGestureRecognizer(() => {
if (!temperatureSensorLocked)
{
temperatureSensor = null;
buttonTemperatureUnit.Enabled = false;
ClearTemperatureInput();
}
}));
editTemperature.AddTarget((object obj, EventArgs args) => {
try {
if (temperatureSensor != null && temperatureSensor.isEditable)
{
var measurement = temperatureUnit.OfScalar(double.Parse(editTemperature.Text));
((ManualSensor)temperatureSensor).SetMeasurement(measurement);
}
////if user removes a temperature sensor, they need to be able to create a new manual sensor
if (temperatureSensor == null)
{
temperatureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Temperature, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Temperature).OfScalar(0.0), false);
var measurement = temperatureUnit.OfScalar(double.Parse("0.00"));
((ManualSensor)temperatureSensor).SetMeasurement(measurement);
}
buttonTemperatureUnit.Enabled = true;
} catch (Exception e) {
Log.E(this, "Failed to UpdateTemperature: invalid string " + editTemperature.Text + ".", e);
}
UpdateDelta();
}, UIControlEvent.EditingChanged);
editPressure.EditingDidEnd += (s, e) => {
if (string.IsNullOrEmpty(editPressure.Text))
{
((ManualSensor)pressureSensor).SetMeasurement(pressureSensor.unit.OfScalar(0));
}
};
if (initialSensor != null)
{
var sensor = initialSensor;
if (ESensorType.Pressure == sensor.type)
{
pressureSensor = sensor;
if (initialSensor.linkedSensor != null)
{
temperatureSensor = initialSensor.linkedSensor;
}
else
{
temperatureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Temperature, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Temperature).OfScalar(0.0), false);
}
}
else if (ESensorType.Temperature == sensor.type)
{
temperatureSensor = sensor;
if (initialSensor.linkedSensor != null)
{
pressureSensor = initialSensor.linkedSensor;
}
else
{
pressureSensor = new ManualSensor(ion.manualSensorContainer, ESensorType.Pressure, AppState.context.preferences.units.DefaultUnitFor(ESensorType.Pressure).OfScalar(0.0), true);
}
}
else
{
Log.E(this, "Cannot accept sensor that is not a pressure or temperature sensor");
//throw new Exception("Cannot accept sensor that is not a pressure or temperature sensor");
}
}
}
