/// <summary>
/// Parses the serial number from the given packet.
/// </summary>
/// <returns>The serial number.</returns>
/// <param name="packtIn">Packet in.</param>
public static bool ParseSerialNumber(byte[] packetIn, out GaugeSerialNumber serialNumber)
{
var packet = System.Text.Encoding.UTF8.GetString(packetIn, 0, packetIn.Length);
Log.D("ClassicProtocol", "Packet is: '" + packet + "'");
var tokens = packet.Split(new char[] { ' ' });
if (tokens.Length != 10)
{
serialNumber = null;
return(false);
}
var usn = tokens[5];
if (GaugeSerialNumber.IsValid(usn))
{
serialNumber = GaugeSerialNumber.Parse(usn);
return(true);
}
else
{
serialNumber = null;
return(false);
}
}
public GaugeDeviceCalibrationCertificate ToCalibrationCertificate()
{
var ret = new GaugeDeviceCalibrationCertificate();
ret.controlSerial = controlDevice.serial;
ret.controlInstrument = controlDevice.instrumentModel;
ret.controlTransducer = controlDevice.transducerModel;
ret.controlAccuracy = controlDevice.accuracy;
ret.testSerialNumber = GaugeSerialNumber.Parse(serialNumber);
ret.testPartNumber = partNumber;
ret.testAccuracy = accuracyLimit;
ret.environmentTemperature = temperature;
ret.environmentHumidity = humidity;
ret.certifiedBy = certifiedBy;
var parts = controlDevice.calDate.Split('-');
ret.lastControlCalibrationDate = new DateTime(int.Parse(parts[0]), int.Parse(parts[1]), int.Parse(parts[2]));
parts = calDate.Split('-');
ret.lastTestCalibrationDate = new DateTime(int.Parse(parts[0]), int.Parse(parts[1]), int.Parse(parts[2]));
ret.calibrationDataPoints.Add("calibrationStandard", performanceData.standardValues.ToArray());
ret.calibrationDataPoints.Add("appionGauge", performanceData.gaugeValues.ToArray());
ret.calibrationDataPoints.Add("minReading", performanceData.minValues.ToArray());
ret.calibrationDataPoints.Add("maxReading", performanceData.maxValues.ToArray());
ret.calibrationDataPoints.Add("calibrationUnit", performanceData.gaugeUnits.ToArray());
return(ret);
}
/// <summary>
/// Attempts to resolve the serial number of the connection.
/// </summary>
/// <returns>The serial number.</returns>
public static Task <GaugeSerialNumber> ResolveSerialNumber(BluetoothDevice device)
{
return(Task.Factory.StartNew(() => {
var connection = new ClassicConnection(device);
try {
if (connection.ConnectInternal())
{
GaugeSerialNumber ret = null;
int tries = 5;
while (ret == null && tries-- > 0)
{
var packet = connection.RequestPacket().Result;
ClassicProtocol.ParseSerialNumber(System.Text.Encoding.UTF8.GetBytes(packet), out ret);
}
return ret;
}
else
{
Log.E(connection, "Failed to resolve serial number: failed to connect.");
return null;
}
} finally {
connection.Disconnect();
}
}));
}
/// <summary>
/// Queries the Android drawable resource id for the given device.
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
public static int GetDeviceIcon(this IDevice device)
{
switch (device.type)
{
case EDeviceType.Gauge: {
GaugeSerialNumber serialNumber = (GaugeSerialNumber)device.serialNumber;
return(GetGaugeIcon(serialNumber.deviceModel));
}
default: {
return(Resource.Drawable.ic_logo_appiondefault);
}
}
}
/// <summary>
/// Queries the Android string resource name for the given device.
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
public static string GetDeviceProductName(this IDevice device)
{
var ion = (BaseAndroidION)AppState.context;
switch (device.type)
{
case EDeviceType.Gauge:
GaugeSerialNumber serialNumber = (GaugeSerialNumber)device.serialNumber;
return(GetTypeString(serialNumber.deviceModel));
default:
return(ion.context.GetString(Resource.String.device_unknown));
}
}
// Overridden from ISensorModel
public Sensor ToSensor(IION ion)
{
var serial = GaugeSerialNumber.Parse(rawSerial);
var device = ion.deviceManager[serial] as GaugeDevice;
if (device != null)
{
return(device[index]);
}
else
{
return(null);
//throw new Exception("Failed to convert GaugeDeviceSensorModel to GaugeDeviceSensor");
}
}
/// <summary>
/// Called when the scan delegate discovers a new device.
/// </summary>
/// <param name="device">Device.</param>
/// <param name="scanRecord">Scan record.</param>
private void OnDeviceFound(BluetoothDevice device, byte[] scanRecord)
{
try {
if (!IsAppionDevice(device))
{
return; // Break as we don't want to deal with none Appion devices
}
var serialNumber = GaugeSerialNumber.Parse(device.Name);
int protocol = (int)scanRecord?[0];
NotifyDeviceFound(serialNumber, device.Address, scanRecord, protocol);
} catch (Exception e) {
Log.E(this, "Failed to resolve found device " + device.Name, e);
}
}
/// <summary>
/// Parses the provided packet. If the packet cannot be parsed, this method will
/// throw an argument exception.
/// </summary>
/// <param name="packet">The packet to parse.</param>
/// <returns></returns>
/// <param name="packetIn">Packet in.</param>
public GaugePacket ParsePacket(byte[] packetIn)
{
var packet = System.Text.Encoding.UTF8.GetString(packetIn, 0, packetIn.Length);
packet = packet.Trim();
var tokens = packet.Split(new char[] { ' ' });
var battery = int.Parse(tokens[2]);
var serialNumber = GaugeSerialNumber.Parse(tokens[5]);
var meas = double.Parse(tokens[8]);
Unit ru;
GaugeReading gr;
if (EDeviceModel.AV760 == serialNumber.deviceModel)
{
ru = vacuumUnitLookup[tokens[9].ToLower()];
gr = new GaugeReading()
{
removed = false,
sensorType = ESensorType.Vacuum,
reading = ru.OfScalar(meas),
};
}
else
{
ru = pressureUnitLookup[tokens[9].ToLower()];
gr = new GaugeReading()
{
removed = false,
sensorType = ESensorType.Pressure,
reading = ru.OfScalar(meas),
};
}
return(new GaugePacket(version, battery, new GaugeReading[] { gr }));
}
/// <summary>
/// Requests the calibration certificates for all of the task's serial numbers.
/// </summary>
/// <param name="tokenSource">Token source.</param>
public async Task <List <CalibrationCertificateRequestResult> > Request()
{
started = true;
try {
var ct = tokenSource.Token;
var ret = new List <CalibrationCertificateRequestResult>();
var data = BuildPostData();
// Bail if cancelled.
ct.ThrowIfCancellationRequested();
// Build Request
var req = (HttpWebRequest)WebRequest.Create(SERVER);
req.ContentType = TYPE_JSON;
req.Method = METHOD_POST;
using (var stream = req.GetRequestStream()) {
stream.Write(data, 0, data.Length);
stream.Flush();
stream.Close();
}
// Bail if cancelled.
ct.ThrowIfCancellationRequested();
// Await Response
var res = (HttpWebResponse)req.GetResponse();
// Bail if cancelled.
ct.ThrowIfCancellationRequested();
using (var stream = new StreamReader(res.GetResponseStream())) {
var result = stream.ReadToEnd();
var obj = JObject.Parse(result);
foreach (var s in obj.Properties())
{
try {
var settings = new JsonSerializerSettings();
settings.MissingMemberHandling = MissingMemberHandling.Ignore;
var response = JsonConvert.DeserializeObject <CalibrationCertificateResponse>(s.Value.ToString());//, settings);
if (response.errorCode != null)
{
Log.E(this, "Failed to get calibration certificate for: " + response.serialNumber + "{" + response.errorCode + "}");
ret.Add(new CalibrationCertificateRequestResult(GaugeSerialNumber.Parse(s.Name)));
}
else
{
ret.Add(new CalibrationCertificateRequestResult(response.ToCalibrationCertificate()));
}
} catch (Exception e) {
Log.E(this, "Failed to parse certificate: " + s.Value, e);
ret.Add(new CalibrationCertificateRequestResult(GaugeSerialNumber.Parse(s.Name)));
}
}
}
return(ret);
} finally {
started = false;
}
}
/// <summary>
/// Queries whether or not the given device is a valid Appion device.
/// </summary>
/// <returns><c>true</c> if this instance is appion device the specified device; otherwise, <c>false</c>.</returns>
/// <param name="device">Device.</param>
private bool IsAppionDevice(BluetoothDevice device)
{
return(GaugeSerialNumber.IsValid(device.Name));
}
/// <summary>
/// Requests the calibration certificates for all of the task's serial numbers.
/// </summary>
/// <param name="tokenSource">Token source.</param>
public async Task <List <CalibrationCertificateRequestResult> > Request()
{
started = true;
Log.D(this, "Inside Request()");
try {
var ct = tokenSource.Token;
var ret = new List <CalibrationCertificateRequestResult>();
var data = BuildPostData();
// Bail if cancelled.
ct.ThrowIfCancellationRequested();
// Build Request
var req = (HttpWebRequest)WebRequest.Create(SERVER);
req.ContentType = TYPE_JSON;
req.Method = METHOD_POST;
using (var stream = req.GetRequestStream()) {
stream.Write(data, 0, data.Length);
stream.Flush();
stream.Close();
}
// Bail if cancelled.
ct.ThrowIfCancellationRequested();
// Await Response
var res = (HttpWebResponse)req.GetResponse();
// Bail if cancelled.
ct.ThrowIfCancellationRequested();
using (var stream = new StreamReader(res.GetResponseStream())) {
var result = stream.ReadToEnd();
Log.D(this, "Raw result: " + result);
var obj = JObject.Parse(result);
foreach (var s in obj.Properties())
{
try {
var settings = new JsonSerializerSettings();
settings.MissingMemberHandling = MissingMemberHandling.Ignore;
var response = JsonConvert.DeserializeObject <CalibrationCertificateResponse>(s.Value.ToString());//, settings);
Log.D(this, "Nist date is " + response.calDate);
if (response.errorCode != null)
{
Log.E(this, "Failed to get calibration certificate for: " + response.serialNumber + "{" + response.errorCode + "}");
ret.Add(new CalibrationCertificateRequestResult(GaugeSerialNumber.Parse(s.Name)));
}
else
{
ret.Add(new CalibrationCertificateRequestResult(response.ToCalibrationCertificate()));
var existing = ion.database.Query <ION.Core.Database.LoggingDeviceRow>("SELECT * FROM LoggingDeviceRow WHERE serialNumber = ?", response.serialNumber);
if (existing.Count.Equals(0))
{
Log.D(this, "Creating new entry for device: " + response.serialNumber + " with a calibration date of: " + response.calDate);
var addDevice = new ION.Core.Database.LoggingDeviceRow()
{
serialNumber = response.serialNumber, nistDate = response.calDate
};
ion.database.Insert(addDevice);
}
else
{
Log.D(this, "Updating last calibration date of: " + response.calDate + " for SN: " + response.serialNumber);
ion.database.Query <ION.Core.Database.LoggingDeviceRow>("UPDATE LoggingDeviceRow SET nistDate = ? WHERE serialNumber = ?", response.calDate, response.serialNumber);
}
}
} catch (Exception e) {
Log.E(this, "Failed to parse certificate: " + s.Value, e);
ret.Add(new CalibrationCertificateRequestResult(GaugeSerialNumber.Parse(s.Name)));
}
}
}
return(ret);
} finally {
started = false;
}
}
protected DeviceParcelable(Parcel source)
{
serialNumber = GaugeSerialNumber.Parse(source.ReadString());
}
public GaugeDeviceSensorParcelable(Parcel source)
{
serialNumber = GaugeSerialNumber.Parse(source.ReadString());
index = source.ReadInt();
}
