// Find table entry given index.
// Returns entry or null.
public DeviceParameter Find(int index)
{
DeviceParameter d = null;
IndexTable.TryGetValue(index, out d);
return(d);
}
public string GetParameters(string parameterNameOrIndex)
{
if (!String.IsNullOrWhiteSpace(parameterNameOrIndex))
{
DeviceParameter d = Find(parameterNameOrIndex);
if (d != null)
{
return(d.ToString());
}
}
return(null);
}
// Get field value from table entry.
// Returns null if not found.
public object GetField(string parameterNameOrIndex, string fieldNameOrId)
{
if (!String.IsNullOrWhiteSpace(parameterNameOrIndex))
{
DeviceParameter d = Find(parameterNameOrIndex);
if (d != null)
{
switch (DeviceParameter.GetFieldId(fieldNameOrId))
{
case DeviceParameter.FieldId.IndexField:
return(d.ParamIndex);
case DeviceParameter.FieldId.CategoryField:
return(d.ParamCategory);
case DeviceParameter.FieldId.VariableKindField:
return(d.ParamVarKind);
case DeviceParameter.FieldId.SizeField:
return(d.ParamSize);
case DeviceParameter.FieldId.StorageFlagsField:
return(d.ParamStorageFlags);
case DeviceParameter.FieldId.MinValueField:
return(d.MinValue);
case DeviceParameter.FieldId.MaxValueField:
return(d.MaxValue);
case DeviceParameter.FieldId.DefaultValueField:
return(d.DefaultValue);
case DeviceParameter.FieldId.RamValueField:
return(d.RamValue);
case DeviceParameter.FieldId.EepromValueField:
return(d.EEPromValue);
case DeviceParameter.FieldId.NameField:
return(d.ParamName);
default:
break;
}
}
}
return(null);
}
// Find table entry given name or index.
// Returns entry or null.
public DeviceParameter Find(string nameOrIndex)
{
DeviceParameter d = null;
if (!String.IsNullOrWhiteSpace(nameOrIndex))
{
int val;
if (int.TryParse(nameOrIndex, out val))
{
IndexTable.TryGetValue(val, out d);
}
else
{
nameOrIndex = nameOrIndex.Trim().ToLower();
NameTable.TryGetValue(nameOrIndex, out d);
}
}
return(d);
}
// Add or update table entry.
public void Add(DeviceParameter d)
{
if (d != null)
{
lock (IndexTable) {
if (!String.IsNullOrWhiteSpace(d.ParamName))
{
NameTable[d.ParamName] = d;
}
if (d.ParamIndex >= 0)
{
IndexTable[d.ParamIndex] = d;
if (d.ParamIndex > LastEntry)
{
LastEntry = d.ParamIndex;
}
}
}
}
}
// Add an entry to table.
// Returns null on success, otherwise error message.
public string Put(int parameterIndex, int parameterCategory, int parameterVarKind,
int parameterSize, int parameterStorageFlags,
Object minValue, Object maxValue, Object defaultValue,
Object ramValue, Object eepromValue, string parameterName)
{
DeviceParameter d = new DeviceParameter();
VariableKind s;
try {
d.ParamIndex = parameterIndex;
d.ParamCategory = parameterCategory;
d.ParamVarKind = VariableValue.StringToVK(parameterVarKind.ToString());
if (d.ParamVarKind == VariableKind.VK_String)
{
s = VariableKind.VK_Byte;
}
else
{
s = d.ParamVarKind;
}
if (parameterSize < 0)
{
d.ParamSize = VariableValue.DataSize(d.ParamVarKind);
}
else
{
d.ParamSize = parameterSize;
}
d.ParamStorageFlags = VariableValue.StringToSF(parameterStorageFlags.ToString());
d.MinValue = new VariableValue(s, minValue.ToString());
d.MaxValue = new VariableValue(s, maxValue.ToString());
d.DefaultValue = new VariableValue(s, defaultValue.ToString());
d.RamValue = new VariableValue(d.ParamVarKind, ramValue.ToString());
d.EEPromValue = new VariableValue(d.ParamVarKind, eepromValue.ToString());
d.ParamName = (parameterName == null?null:parameterName.Trim().ToLower());
Add(d);
} catch (Exception e) {
return("Error: parameter field in wrong format:" + e.Message);
}
return(null);
}
// Add an entry to table.
// deviceParameterFields must correspond to DeviceParameter fields in order.
// Returns null if entry was added, otherwise error message.
public string Put(Object[] deviceParameterFields)
{
if (deviceParameterFields != null && deviceParameterFields.Length == DeviceParameter.FieldNames.Length)
{
DeviceParameter.FieldId fieldId = 0;
try {
DeviceParameter d = new DeviceParameter();
fieldId = DeviceParameter.FieldId.IndexField;
d.ParamIndex = Convert.ToInt32(deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.CategoryField;
d.ParamCategory = Convert.ToInt32(deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.VariableKindField;
d.ParamVarKind = VariableValue.StringToVK(deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.SizeField;
d.ParamSize = Convert.ToInt32(deviceParameterFields[(int)fieldId].ToString());
if (d.ParamSize < 0)
{
d.ParamSize = VariableValue.DataSize(d.ParamVarKind);
}
fieldId = DeviceParameter.FieldId.StorageFlagsField;
d.ParamStorageFlags = VariableValue.StringToSF(deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.MinValueField;
d.MinValue = new VariableValue(d.ParamVarKind, deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.MaxValueField;
d.MaxValue = new VariableValue(d.ParamVarKind, deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.DefaultValueField;
d.DefaultValue = new VariableValue(d.ParamVarKind, deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.RamValueField;
d.RamValue = new VariableValue(d.ParamVarKind, deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.EepromValueField;
d.EEPromValue = new VariableValue(d.ParamVarKind, deviceParameterFields[(int)fieldId].ToString());
fieldId = DeviceParameter.FieldId.NameField;
d.ParamName = deviceParameterFields[(int)fieldId].ToString().Trim().ToLower();
Add(d);
} catch (Exception e) {
return("Error: parameter field " + DeviceParameter.FieldNames[(int)fieldId] + " in wrong format:" + e.Message);
}
return(null);
}
return("Error: not enough parameter fields in array.");
}
// Process read variable reply.
// <cmd,> {readId, cmdFlags, page, numRead:numToRead, {parameterIndex}+ } [data]*.
// Store results in tables.
public static int ProcessReadVarMessage(BabelMessage msg,
ParameterManager manager,
Dictionary <int, DeviceParameter> indexTable,
Dictionary <string, DeviceParameter> nameTable,
Dictionary <int, String> indexToNameTable,
List <long> offsetTable = null)
{
int numProcessed = 0;
if (msg.DataLen > 5)
{
DeviceParameter d;
String name;
bool hasRamValue, hasEEPromValue, hasDefaultValue;
bool hasMinMaxValue, hasDataFlags;
bool isNewParam, notInNameTable, notInIndexTable;
bool hasMeta, hasKindOnly;
VariableKind paramVarKind;
VariableValue ramValue, eepromValue, defaultValue;
VariableValue minValue, maxValue;
int readId, cmdFlags, pageNum, pIdx, numRead, numToRead, dataSize, dataFlags, argsFlags;
int idx = 0, n = msg.DataLen, offsetIndex = 0;
readId = (msg.DataAry[idx++] & 0xff);
cmdFlags = (msg.DataAry[idx++] & 0xff);
pageNum = (msg.DataAry[idx++] & 0xff);
numToRead = (msg.DataAry[idx] & 0x0f);
numRead = (msg.DataAry[idx++] & 0xf0) >> 4;
pIdx = idx;
idx += numToRead;
if (numRead == 0)
{
return(numProcessed);
}
hasKindOnly = ((cmdFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_PACK_KIND) != 0);
hasMeta = hasKindOnly || ((cmdFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_PACK) == 0);
// Now read in values.
while (idx < n)
{
int paramIndex = msg.DataAry[pIdx++];
d = null;
name = null;
hasRamValue = false;
hasEEPromValue = false;
hasDefaultValue = false;
hasMinMaxValue = false;
hasDataFlags = false;
isNewParam = false;
notInNameTable = true;
notInIndexTable = true;
dataFlags = 0;
defaultValue = null;
eepromValue = null;
ramValue = null;
minValue = null;
maxValue = null;
// First get VariableKind.
if (hasMeta)
{
paramVarKind = (VariableKind)(msg.DataAry[idx++] & 0xff);
}
else
{
if (indexTable == null)
{
return(numProcessed);
}
indexTable.TryGetValue(paramIndex, out d);
notInIndexTable = (d == null);
if (d == null)
{
return(numProcessed);
}
paramVarKind = d.ParamVarKind;
}
dataSize = VariableValue.DataSize(paramVarKind);
if (paramVarKind != VariableKind.VK_None)
{
if (dataSize == 0)
{
return(numProcessed);
}
if (hasMeta && !hasKindOnly)
{
// Next read StorageFlags.
if ((idx + 1) <= n)
{
hasDataFlags = true;
dataFlags = (msg.DataAry[idx++] & 0xff);
}
else
{
return(numProcessed);
}
// Next read ArgsFlags.
if ((idx + 1) <= n)
{
argsFlags = (msg.DataAry[idx++] & 0xff);
}
else
{
return(numProcessed);
}
offsetIndex = idx;
}
else
{
if (hasKindOnly)
{
offsetIndex = idx;
}
hasDataFlags = true;
dataFlags = (int)StorageFlags.SF_Dynamic;
argsFlags = ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_RAM;
}
// Then work through cmdFlags:
if ((argsFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_RAM) != 0)
{
if ((idx < n) && (paramVarKind == VariableKind.VK_String))
{
dataSize = (msg.DataAry[idx++] & 0xff);
}
if ((idx + dataSize) <= n)
{
hasRamValue = true;
ramValue = new VariableValue(paramVarKind, msg.DataAry, idx, dataSize);
idx += dataSize;
}
else
{
return(numProcessed);
}
}
if ((argsFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_EEPROM) != 0)
{
if ((idx < n) && (paramVarKind == VariableKind.VK_String))
{
dataSize = (msg.DataAry[idx++] & 0xff);
}
if ((idx + dataSize) <= n)
{
hasEEPromValue = true;
eepromValue = new VariableValue(paramVarKind, msg.DataAry, idx, dataSize);
idx += dataSize;
}
else
{
return(numProcessed);
}
}
if ((argsFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_DEFAULT) != 0)
{
if ((idx + dataSize) <= n)
{
hasDefaultValue = true;
defaultValue = new VariableValue(paramVarKind, msg.DataAry, idx, dataSize);
idx += dataSize;
}
else
{
return(numProcessed);
}
}
if ((argsFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_RANGE) != 0)
{
// Read in dataSize, category, min, max.
if ((idx + 2 + 2 * dataSize) <= n)
{
idx++; // Skip dataSize.
idx++; // Skip category.
hasMinMaxValue = true;
minValue = new VariableValue(paramVarKind, msg.DataAry, idx, dataSize);
idx += dataSize;
maxValue = new VariableValue(paramVarKind, msg.DataAry, idx, dataSize);
idx += dataSize;
}
else
{
return(numProcessed);
}
}
// Finally check for name.
if ((argsFlags & ProtocolConstants.MEDIATOR_DEVICE_RWV_FLAGS_NAME) != 0)
{
byte[] buffer = new byte[msg.DataAry.Length];
byte b;
int k = 0, len = 0;
if (idx < n) // Get len byte.
{
len = (msg.DataAry[idx++] & 0xff);
}
while (idx < n)
{
if (len-- == 0)
{
break;
}
b = (byte)(msg.DataAry[idx++] & 0xff);
if (b == 0)
{
break;
}
buffer[k++] = b;
}
try {
name = Encoding.UTF8.GetString(buffer, 0, k);
} catch (Exception) {
name = null;
}
if (name != null)
{
name = name.Trim().ToUpper();
if (name.Length < 2 || name.Length > 8)
{
name = null;
}
}
}
}
if (hasMeta && (offsetTable != null) && (offsetIndex < idx))
{
offsetTable.Add((paramIndex << 24) | (((int)paramVarKind) << 16) | (dataSize << 8) | offsetIndex);
}
// Now update device profile.
if (name == null && indexToNameTable != null)
{
indexToNameTable.TryGetValue(paramIndex, out name);
if (name == null)
{
Log.w(TAG, "ProcessReadVarMessage: no name for device parameter:" + paramIndex + ".");
}
}
// First look for parameter by name:
if (name != null && nameTable != null)
{
nameTable.TryGetValue(name, out d);
notInNameTable = (d == null);
}
if (d == null && indexTable != null)
{
indexTable.TryGetValue(paramIndex, out d);
notInIndexTable = (d == null);
}
if (d != null && name != null)
{
d.ParamName = name;
}
if (d == null)
{
d = new DeviceParameter(name, paramIndex, paramVarKind, (StorageFlags)dataFlags, dataSize, hasMinMaxValue, minValue, maxValue, defaultValue);
isNewParam = true;
}
if (hasDataFlags)
{
d.ParamStorageFlags = (StorageFlags)dataFlags;
d.IsDynamic = ((dataFlags & (int)StorageFlags.SF_Dynamic) != 0);
d.IsReadOnly = ((dataFlags & (int)StorageFlags.SF_ReadOnly) != 0);
d.IsEEProm = ((dataFlags & (int)StorageFlags.SF_EEPROM) != 0);
if (!d.IsEEProm)
{
hasEEPromValue = false;
}
}
if (hasRamValue)
{
if (isNewParam || !VariableValue.Equal(ramValue, d.RamValue))
{
d.HasChanged = true;
}
d.RamValue = ramValue;
d.HasRamValue = true;
}
if (hasEEPromValue)
{
if (isNewParam || !VariableValue.Equal(eepromValue, d.EEPromValue))
{
d.HasChanged = true;
}
d.EEPromValue = eepromValue;
d.HasEEPromValue = true;
}
if (hasDefaultValue)
{
if (isNewParam || !VariableValue.Equal(defaultValue, d.DefaultValue))
{
d.HasChanged = true;
}
d.DefaultValue = defaultValue;
d.HasDefaultValue = true;
}
if (hasMinMaxValue)
{
if (isNewParam || (d.MinValue != minValue) || (d.MaxValue != maxValue))
{
d.HasChanged = true;
}
if (!isNewParam)
{
d.UpdateMinAndMax(true, minValue, maxValue);
}
}
// Finally, make sure it's in the tables:
if (notInNameTable && nameTable != null && (name != null))
{
nameTable[name] = d;
}
if (notInIndexTable && indexTable != null)
{
indexTable[paramIndex] = d;
}
d.RequiresRefresh = false;
if (manager != null)
{
manager.NotifyChangeListeners(d);
manager.CheckVerifiedWrites(d);
}
++numProcessed;
}
}
return(numProcessed);
}
private void CheckVerifiedWrites(DeviceParameter d)
{
}
private void NotifyChangeListeners(DeviceParameter d)
{
}
// Update a field in a table entry. Create new entry if necessary.
// Returns null on success, otherwise error message.
public string PutField(string parameterNameOrIndex, string fieldNameOrId, object value)
{
string result = null;
if (!String.IsNullOrWhiteSpace(parameterNameOrIndex) && value != null)
{
DeviceParameter d = Find(parameterNameOrIndex);
bool isNew = (d == null);
if (isNew)
{
d = new DeviceParameter(parameterNameOrIndex);
}
switch (DeviceParameter.GetFieldId(fieldNameOrId))
{
case DeviceParameter.FieldId.IndexField:
try {
int v = (int)value;
if (v >= 0)
{
if (!isNew && d.ParamIndex >= 0)
{
IndexTable.Remove(d.ParamIndex);
}
d.ParamIndex = v;
isNew = true;
}
else
{
result = "Error: negative index.";
}
} catch (Exception) {
result = "Error: invalid index type.";
}
break;
case DeviceParameter.FieldId.CategoryField:
try {
int v = (int)value;
if (v >= 0)
{
d.ParamCategory = v;
}
else
{
result = "Error: negative category.";
}
} catch (Exception) {
result = "Error: invalid category type.";
}
break;
case DeviceParameter.FieldId.VariableKindField:
try {
VariableKind v = VariableValue.StringToVK(value.ToString());
d.ParamVarKind = v;
if (v == VariableKind.VK_None)
{
result = "Error: bad representation kind.";
}
} catch (Exception) {
result = "Error: invalid representation kind type.";
}
break;
case DeviceParameter.FieldId.SizeField:
try {
int v = (int)value;
if (v >= 0)
{
d.ParamSize = v;
}
else
{
d.ParamSize = VariableValue.DataSize(d.ParamVarKind);
}
} catch (Exception) {
result = "Error: invalid size value.";
}
break;
case DeviceParameter.FieldId.StorageFlagsField:
try {
StorageFlags v = VariableValue.StringToSF(value.ToString());
d.ParamStorageFlags = v;
if (v == StorageFlags.SF_None)
{
result = "Error: bad storage flags.";
}
} catch (Exception) {
result = "Error: invalid storage flags type.";
}
break;
case DeviceParameter.FieldId.MinValueField:
try {
d.MinValue = new VariableValue(d.ParamVarKind, value.ToString());
} catch (Exception) {
result = "Error: invalid min value type.";
}
break;
case DeviceParameter.FieldId.MaxValueField:
try {
d.MaxValue = new VariableValue(d.ParamVarKind, value.ToString());
} catch (Exception) {
result = "Error: invalid max value type.";
}
break;
case DeviceParameter.FieldId.DefaultValueField:
try {
d.DefaultValue = new VariableValue(d.ParamVarKind, value.ToString());
} catch (Exception) {
result = "Error: invalid default value type.";
}
break;
case DeviceParameter.FieldId.RamValueField:
try {
d.RamValue = new VariableValue(d.ParamVarKind, value.ToString());
} catch (Exception) {
result = "Error: invalid ram value type.";
}
break;
case DeviceParameter.FieldId.EepromValueField:
try {
d.EEPromValue = new VariableValue(d.ParamVarKind, value.ToString());
} catch (Exception) {
result = "Error: invalid Eeprom value type.";
}
break;
case DeviceParameter.FieldId.NameField:
try {
string s = value.ToString().Trim().ToLower();
if (!isNew && !String.IsNullOrWhiteSpace(d.ParamName))
{
NameTable.Remove(d.ParamName);
}
d.ParamName = s;
isNew = true;
} catch (Exception) {
result = "Error: invalid index type.";
}
break;
default:
result = "Error: invalid field name or Id.";
break;
}
if (isNew && result == null)
{
Add(d);
}
}
return(result);
}
