private Guid GetRecordService(ServiceRecord m_record)
{
ServiceAttribute attr = m_record.GetAttributeById(UniversalAttributeId.ServiceClassIdList);
ServiceElement element = (ServiceElement)attr.Value.GetValueAsElementList()[0];
Guid uuid128 = (Guid)element.Value;
return(uuid128);
}
public ServiceElement[] GetValueAsElementArray()
{
IList_ServiceElement list = GetValueAsElementList();
ServiceElement[] arr = new ServiceElement[list.Count];
GetValueAsElementList().CopyTo(arr, 0);
return(arr);
}
/// <exclude/>
protected virtual int CreateAttrId(ServiceAttributeId attrId, byte[] buf, int offset)
{
ServiceElement dummyElement
= new ServiceElement(
ElementType.UInt16, unchecked ((UInt16)attrId));
return(CreateElement(dummyElement, buf, offset));
}
private void WriteInt64(ServiceElement element, Int64 value, byte[] buf, ref int offset, out int totalLength)
{
Int64 host64 = value;
Int64 net64 = IPAddress.HostToNetworkOrder(host64);
byte[] valueBytes = BitConverter.GetBytes(net64);
WriteFixedLength(element, valueBytes, buf, ref offset, out totalLength);
}
protected virtual void WriteFixedLength(ServiceElement element, byte[] valueBytes, byte[] buf, ref int offset, out int totalLength)
{
int headerLen = WriteHeaderFixedLength(element.ElementTypeDescriptor, valueBytes.Length, buf, offset, out totalLength);
offset += headerLen;
VerifyWriteSpaceRemaining(valueBytes.Length, buf, offset);
valueBytes.CopyTo(buf, offset);
System.Diagnostics.Debug.Assert(totalLength == headerLen + valueBytes.Length);
}
protected virtual void WriteVariableLength(ServiceElement element, byte[] valueBytes, byte[] buf, ref int offset, out int totalLength)
{
HeaderWriteState headerState;
int curLen;
curLen = MakeVariableLengthHeader(buf, offset, element.ElementTypeDescriptor, out headerState);
offset += curLen;
VerifyWriteSpaceRemaining(valueBytes.Length, buf, offset);
valueBytes.CopyTo(buf, offset);//write
offset += valueBytes.Length;
CompleteHeaderWrite(headerState, buf, offset, out totalLength);
}
public String GetMultiLanguageStringAttributeById(ServiceAttributeId id, LanguageBaseItem language)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
ServiceAttributeId actualId = CreateLanguageBasedAttributeId(id, language.AttributeIdBase);
ServiceAttribute attr = GetAttributeById(actualId);
ServiceElement element = attr.Value;
// (No need to check that element is of type TextString, that's handled inside the following).
String str = element.GetValueAsString(language);
return(str);
}
/// <summary>
/// Add a custom attribute of simple type.
/// </summary>
/// -
/// <remarks>
/// <para>If the <paramref name="elementType"/> is a numerical type
/// then this is equivalent to using
/// <see cref="M:InTheHand.Net.Bluetooth.ServiceElement.CreateNumericalServiceElement(InTheHand.Net.Bluetooth.ElementType,System.Object)"/>
/// otherwise the value is used directly in creating the
/// <see cref="T:InTheHand.Net.Bluetooth.ServiceElement"/>.
/// </para>
/// </remarks>
/// -
/// <param name="id">The Attribute Id as a <see cref="T:InTheHand.Net.Bluetooth.ServiceAttributeId"/>.</param>
/// <param name="elementType">The type of the element as an <see cref="T:InTheHand.Net.Bluetooth.ElementType"/>.</param>
/// <param name="value">The value for the new element.</param>
public void AddCustomAttribute(ServiceAttributeId id, ElementType elementType, object value)
{
ServiceElement e;
ElementTypeDescriptor etd = ServiceRecordParser.GetEtdForType(elementType);
if ((etd == ElementTypeDescriptor.UnsignedInteger ||
etd == ElementTypeDescriptor.TwosComplementInteger))
{
e = ServiceElement.CreateNumericalServiceElement(elementType, value);
}
else
{
e = new ServiceElement(elementType, value);
}
this.AddCustomAttribute(new ServiceAttribute(id, e));
}
/// <summary>
/// Get the enum-like class containing the Service Attribute Id definitions
/// for the type of the Service Class contained in the given
/// <see cref="F:InTheHand.Net.Bluetooth.AttributeIds.UniversalAttributeId.ServiceClassIdList"/>
/// (type <see cref="F:InTheHand.Net.Bluetooth.ElementTypeDescriptor.Uuid"/>) data element.
/// </summary>
/// -
/// <param name="idElement">A <see cref="T:InTheHand.Net.Bluetooth.ServiceElement"/>
/// of 'UUID' type containing the Service Class to search for.
/// </param>
/// -
/// <returns>
/// A <see cref="T:System.Type"/> object representing the enum-like class
/// holding the Attribute Id definitions, or null if the Service Class is
/// unknown or the element is not of <see cref="F:InTheHand.Net.Bluetooth.ElementTypeDescriptor.Uuid"/>
/// type.
/// </returns>
/// -
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="idElement"/> is null.
/// </exception>
protected virtual Type GetAttributeIdEnumType(ServiceElement idElement)
{
if (idElement == null)
{
throw new ArgumentNullException("idElement");
}
//
if (idElement.ElementTypeDescriptor != ElementTypeDescriptor.Uuid)
{
return(null);
}
Guid uuid = idElement.GetValueAsUuid();
//
return(GetAttributeIdEnumType(uuid));
}
private static ServiceElement ServiceElementFromUuid(object classRaw)
{
ServiceElement tmp = null;
UInt32 classU32 = 99;
bool writeIntegral;
// First check raw type, and also if u16/u32 inside Guid.
// If Guid write it, otherwise handle all integral value.
if (classRaw is Guid)
{
Guid uuid128 = (Guid)classRaw;
if (ServiceRecordUtilities.IsUuid32Value(uuid128))
{
classU32 = ServiceRecordUtilities.GetAsUuid32Value(uuid128);
writeIntegral = true;
}
else
{
tmp = new ServiceElement(ElementType.Uuid128, uuid128);
writeIntegral = false;
}
}
else
{
System.Diagnostics.Debug.Assert(classRaw != null,
"Unexpected ServiceClassId value: null");
System.Diagnostics.Debug.Assert(classRaw is Int32,
"Unexpected ServiceClassId type: " + classRaw.GetType().Name);
Int32 i32 = (Int32)classRaw;
classU32 = unchecked ((UInt32)i32);
writeIntegral = true;
}
if (writeIntegral)
{
try {
UInt16 u16 = Convert.ToUInt16(classU32);
Debug.Assert(classU32 <= UInt16.MaxValue, "NOT replace the throw, LTE");
tmp = new ServiceElement(ElementType.Uuid16, u16);
} catch (OverflowException) {
Debug.Assert(classU32 > UInt16.MaxValue, "NOT replace the throw, GT");
tmp = new ServiceElement(ElementType.Uuid32, classU32);
}
}
return(tmp);
}
//--------------------------------------------------------------
private static ServiceRecord CreateRecord()
{
List_ServiceAttribute attrs = new List_ServiceAttribute();
ServiceElement element;
//
element = new ServiceElement(ElementType.ElementSequence,
new ServiceElement(ElementType.Uuid128, Guid.Empty));
attrs.Add(new ServiceAttribute(UniversalAttributeId.ServiceClassIdList, element));
//
element = ServiceRecordHelper.CreateRfcommProtocolDescriptorList();
attrs.Add(new ServiceAttribute(UniversalAttributeId.ProtocolDescriptorList, element));
//
ServiceRecord record = new ServiceRecord(attrs);
return(record);
}
private static void DumpString(System.IO.TextWriter writer, int depth, ServiceElement element, LanguageBaseItem langBase)
{
if (langBase != null)
{
try {
String value = element.GetValueAsString(langBase);
writer.WriteLine("{0}: [{1}] '{2}'", element.ElementType, langBase.NaturalLanguage, value);
} catch (NotSupportedException ex) {
System.Diagnostics.Debug.Assert(ex.Message != null);
System.Diagnostics.Debug.Assert(ex.Message.StartsWith("Unrecognized character encoding"));
writer.WriteLine("{0}: Failure: {1}", element.ElementType, ex.Message);
}
}
else
{
try {
String hack = element.GetValueAsStringUtf8();
if (hack.IndexOf((char)0) != -1)
{
throw new
#if !WinCE
System.Text.DecoderFallbackException
#else
// NETCF doesn't support DecoderFallbackException this what the docs say.
ArgumentException
#endif
("EEEEE contains nulls! UTF-16?!");
}
writer.WriteLine("{0} (guessing UTF-8): '{1}'", element.ElementType, hack);
} catch (
// TODO ! What exception thrown by UTF8Encoding on NETCF?
#if !WinCE
System.Text.DecoderFallbackException
#else
// NETCF doesn't support DecoderFallbackException this what the docs say.
ArgumentException
#endif
) {
writer.WriteLine("{0} (Unknown/bad encoding):", element.ElementType);
var arr = (byte[])element.Value;
var str = BitConverter.ToString(arr);
WritePrefix(writer, depth); // On another line.
writer.WriteLine("Length: {0}, >>{1}<<", arr.Length, str);
}//try
}
}
private static void DumpRawElement(System.IO.TextWriter writer, int depth, ServiceElement elem)
{
WritePrefix(writer, depth);
if (elem.ElementType == ElementType.ElementSequence ||
elem.ElementType == ElementType.ElementAlternative)
{
writer.WriteLine("{0}", elem.ElementType);
foreach (ServiceElement element in elem.GetValueAsElementList())
{
DumpRawElement(writer, depth + 1, element);
}
}
else if (elem.ElementType == ElementType.Nil)
{
writer.WriteLine("Nil:");
}
else if (elem.ElementType == ElementType.TextString ||
elem.ElementType == ElementType.Boolean ||
elem.ElementType == ElementType.Url)
{
// Non-numeric types
writer.WriteLine("{0}: {1}", elem.ElementType, elem.Value);
}
else if (elem.ElementType == ElementType.Uuid128)
{
writer.WriteLine("{0}: {1}", elem.ElementType, elem.Value);
}
else if (elem.ElementType == ElementType.UInt128 ||
elem.ElementType == ElementType.Int128)
{
string valueText = BitConverter.ToString((byte[])elem.Value);
writer.WriteLine("{0}: {1}", elem.ElementType, valueText);
}
else
{
writer.WriteLine("{0}: 0x{1:X}", elem.ElementType, elem.Value);
//{catch(?FOrmatExptn){
// writer.WriteLine("{0}: 0x{1}", elem.Type, elem.Value);
//}
}
}
/// <summary>
/// Get a list of enum-like classes containing Service Attribute Id definitions
/// for the type of the Service Class contained in the given Service Record.
/// </summary>
/// -
/// <param name="record">A <see cref="T:InTheHand.Net.Bluetooth.ServiceRecord"/>
/// whose <see cref="F:InTheHand.Net.Bluetooth.AttributeIds.UniversalAttributeId.ServiceClassIdList"/>
/// element will be retrieved, and its Service Class Id will used
/// for the lookup.
/// </param>
/// -
/// <returns>
/// An array of <see cref="T:System.Type"/> each of which is a enum-like class
/// which defines the set of Service Attribute IDs used by a particular
/// Service Class e.g. ObjectPushProfile.
/// An empty array will be returned if none of the Service Classes
/// are known, or the record contains no
/// <see cref="F:InTheHand.Net.Bluetooth.AttributeIds.UniversalAttributeId.ServiceClassIdList"/>
/// attribute, or it is invalid.
/// <note>Currently only the first Service Class Id is looked-up.</note>
/// </returns>
/// -
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="record"/> is null.
/// </exception>
public Type[] GetAttributeIdEnumTypes(ServiceRecord record)
{
if (record == null)
{
throw new ArgumentNullException("record");
}
//
ServiceAttribute attr;
try {
attr = record.GetAttributeById(UniversalAttributeId.ServiceClassIdList);
} catch (
#if V1
ArgumentException
#else
System.Collections.Generic.KeyNotFoundException
#endif
ex) {
System.Diagnostics.Debug.Assert(ex.Message == ServiceRecord.ErrorMsgNoAttributeWithId);
goto InvalidRecord;
}
ServiceElement element = attr.Value;
if (element.ElementType != ElementType.ElementSequence)
{
goto InvalidRecord;
}
ServiceElement[] idElements = element.GetValueAsElementArray();
//TODO ((GetServiceClassSpecificAttributeIdEnumDefiningType--foreach (ServiceElement curIdElem in idElements) {))
if (idElements.Length != 0)
{
ServiceElement curIdElem = idElements[0];
Type enumType = GetAttributeIdEnumType(curIdElem);
if (enumType != null)
{
return(new Type[] { enumType });
}
}//else fall through...
// None-matched, or invalid attribute format etc.
InvalidRecord:
return(new Type[0]);
}
//--------------------
//
/// <summary>
/// Gets the list of <see cref="T:InTheHand.Net.Bluetooth.LanguageBaseItem"/>
/// items in the service record.
/// </summary>
/// -
/// <param name="elementSequence">
/// A <see cref="T:InTheHand.Net.Bluetooth.ServiceElement"/> holding the
/// data from the
/// <see cref="F:InTheHand.Net.Bluetooth.AttributeIds.UniversalAttributeId.LanguageBaseAttributeIdList"/>
/// attribute.
/// </param>
/// -
/// <returns>
/// An array of <see cref="T:InTheHand.Net.Bluetooth.LanguageBaseItem"/>.
/// An array length zero is returned if the service record contains no such attribute.
/// </returns>
/// -
/// <exception cref="T:System.ArgumentException">
/// <paramref name="elementSequence"/> is not of type
/// <see cref="F:InTheHand.Net.Bluetooth.ElementType.ElementSequence"/>.
/// </exception>
/// <exception cref="T:System.Net.ProtocolViolationException">
/// The element sequence contains incorrectly formatted or invalid content,
/// for example it contains the wrong element data types, or doesn't contain
/// the elements in groups of three as required.
/// </exception>
public static LanguageBaseItem[] ParseListFromElementSequence(ServiceElement elementSequence)
{
if (elementSequence.ElementType != ElementType.ElementSequence)
{
throw new ArgumentException(ErrorMsgLangBaseListParseNotSequence);
}
#if V1
IList elementList = elementSequence.GetValueAsElementList();
#else
IList <ServiceElement> elementList = elementSequence.GetValueAsElementList();
#endif
int numElements = elementList.Count;
const int ElementsPerItem = 3;
if (numElements == 0 || (numElements % ElementsPerItem) != 0)
{
throw new System.Net.ProtocolViolationException(ErrorMsgLangBaseListParseNotInThrees);
}
int numItems = numElements / ElementsPerItem;
LanguageBaseItem[] items = new LanguageBaseItem[numItems];
for (int i = 0; i < numItems; ++i)
{
// Casts are for the non-Generic version.
ServiceElement e1Lang = (ServiceElement)elementList[i * ElementsPerItem];
ServiceElement e2EncId = (ServiceElement)elementList[i * ElementsPerItem + 1];
ServiceElement e3BaseId = (ServiceElement)elementList[i * ElementsPerItem + 2];
if (e1Lang.ElementType != ElementType.UInt16 || e2EncId.ElementType != ElementType.UInt16 || e3BaseId.ElementType != ElementType.UInt16)
{
throw new System.Net.ProtocolViolationException(ErrorMsgLangBaseListParseNotU16);
}
if ((UInt16)e3BaseId.Value == 0)
{
throw new System.Net.ProtocolViolationException(ErrorMsgLangBaseListParseBaseInvalid);
}
LanguageBaseItem item = new LanguageBaseItem(
(UInt16)e1Lang.Value, (UInt16)e2EncId.Value, (UInt16)e3BaseId.Value);
items[i] = item;
}
return(items);
}
private void WriteVariableLength(ServiceElement element, byte[] valueBytes, byte[] buf, ref int offset, out int totalLength)
{
HeaderWriteState headerState;
int curLen;
curLen = MakeVariableLengthHeader(buf, offset, element.ElementTypeDescriptor, out headerState);
offset += curLen;
VerifyWriteSpaceRemaining(valueBytes.Length, buf, offset);
valueBytes.CopyTo(buf, offset);//write
offset += valueBytes.Length;
CompleteHeaderWrite(headerState, buf, offset, out totalLength);
}
private static ServiceElement CreateRfcommProtocolDescriptorListWithUpperLayers(params ServiceElement[] upperLayers)
{
IList_ServiceElement baseChildren = new List_ServiceElement();
baseChildren.Add(CreatePdlLayer((UInt16)ServiceRecordUtilities.HackProtocolId.L2Cap));
baseChildren.Add(CreatePdlLayer((UInt16)ServiceRecordUtilities.HackProtocolId.Rfcomm,
new ServiceElement(ElementType.UInt8, (byte)0)));
foreach (ServiceElement nextLayer in upperLayers) {
if (nextLayer.ElementType != ElementType.ElementSequence) {
throw new ArgumentException("Each layer in a ProtocolDescriptorList must be an ElementSequence.");
}
baseChildren.Add(nextLayer);
}//for
ServiceElement baseElement = new ServiceElement(ElementType.ElementSequence, baseChildren);
return baseElement;
}
private void WriteUInt32(ServiceElement element, UInt32 value, byte[] buf, ref int offset, out int totalLength)
{
Int32 valueS = unchecked((Int32)value);
WriteInt32(element, valueS, buf, ref offset, out totalLength);
}
//--------------------
//
/// <summary>
/// Gets the list of <see cref="T:InTheHand.Net.Bluetooth.LanguageBaseItem"/>
/// items in the service record.
/// </summary>
/// -
/// <param name="elementSequence">
/// A <see cref="T:InTheHand.Net.Bluetooth.ServiceElement"/> holding the
/// data from the
/// <see cref="F:InTheHand.Net.Bluetooth.AttributeIds.UniversalAttributeId.LanguageBaseAttributeIdList"/>
/// attribute.
/// </param>
/// -
/// <returns>
/// An array of <see cref="T:InTheHand.Net.Bluetooth.LanguageBaseItem"/>.
/// An array length zero is returned if the service record contains no such attribute.
/// </returns>
/// -
/// <exception cref="T:System.ArgumentException">
/// <paramref name="elementSequence"/> is not of type
/// <see cref="F:InTheHand.Net.Bluetooth.ElementType.ElementSequence"/>.
/// </exception>
/// <exception cref="T:System.Net.ProtocolViolationException">
/// The element sequence contains incorrectly formatted or invalid content,
/// for example it contains the wrong element data types, or doesn't contain
/// the elements in groups of three as required.
/// </exception>
public static LanguageBaseItem[] ParseListFromElementSequence(ServiceElement elementSequence)
{
if (elementSequence.ElementType != ElementType.ElementSequence) {
throw new ArgumentException(ErrorMsgLangBaseListParseNotSequence);
}
#if V1
IList elementList = elementSequence.GetValueAsElementList();
#else
IList<ServiceElement> elementList = elementSequence.GetValueAsElementList();
#endif
int numElements = elementList.Count;
const int ElementsPerItem = 3;
if (numElements == 0 || (numElements % ElementsPerItem) != 0) {
throw new System.Net.ProtocolViolationException(ErrorMsgLangBaseListParseNotInThrees);
}
int numItems = numElements / ElementsPerItem;
LanguageBaseItem[] items = new LanguageBaseItem[numItems];
for (int i = 0; i < numItems; ++i) {
// Casts are for the non-Generic version.
ServiceElement e1Lang = (ServiceElement)elementList[i * ElementsPerItem];
ServiceElement e2EncId = (ServiceElement)elementList[i * ElementsPerItem + 1];
ServiceElement e3BaseId = (ServiceElement)elementList[i * ElementsPerItem + 2];
if (e1Lang.ElementType != ElementType.UInt16 || e2EncId.ElementType != ElementType.UInt16 || e3BaseId.ElementType != ElementType.UInt16) {
throw new System.Net.ProtocolViolationException(ErrorMsgLangBaseListParseNotU16);
}
if ((UInt16)e3BaseId.Value == 0) {
throw new System.Net.ProtocolViolationException(ErrorMsgLangBaseListParseBaseInvalid);
}
LanguageBaseItem item = new LanguageBaseItem(
(UInt16)e1Lang.Value, (UInt16)e2EncId.Value, (UInt16)e3BaseId.Value);
items[i] = item;
}
return items;
}
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:InTheHand.Net.Bluetooth.ServiceAttribute"/> class.
/// </summary>
public ServiceAttribute(ServiceAttributeId id, ServiceElement value)
{
m_id = id;
m_element = value;
}
[CLSCompliant(false)] // instead use .ctor(ServiceAttributeId,AttributeValue).
public ServiceAttribute(UInt16 id, ServiceElement value)
: this(unchecked ((ServiceAttributeId)(Int16)id), value)
{
}
private static void DumpElement(System.IO.TextWriter writer, int depth, ServiceElement elem)
{
WritePrefix(writer, depth);
if (elem.ElementType == ElementType.ElementSequence || elem.ElementType == ElementType.ElementAlternative)
{
writer.WriteLine("{0}", elem.ElementType);
foreach (ServiceElement element in elem.GetValueAsElementList())
{
DumpElement(writer, depth + 1, element);
}//for
}
else if (elem.ElementType == ElementType.Nil)
{
writer.WriteLine("Nil:");
}
else if (elem.ElementType == ElementType.TextString)
{
DumpString(writer, depth, elem, null);
}
else if (elem.ElementType == ElementType.Boolean ||
elem.ElementType == ElementType.Url)
{
// Non-numeric types
writer.WriteLine("{0}: {1}", elem.ElementType, elem.Value);
}
else
{
String name = null;
String valueText = null;
if (elem.ElementTypeDescriptor == ElementTypeDescriptor.Uuid)
{
if (elem.ElementType == ElementType.Uuid16)
{
name = BluetoothService.GetName((UInt16)elem.Value);
}
else if (elem.ElementType == ElementType.Uuid32)
{
name = BluetoothService.GetName((UInt32)elem.Value);
}
else
{
System.Diagnostics.Debug.Assert(elem.ElementType == ElementType.Uuid128);
name = BluetoothService.GetName((Guid)elem.Value);
valueText = ((Guid)elem.Value).ToString();
}
}//if UUID
if (valueText == null)
{
if (elem.ElementTypeDescriptor == ElementTypeDescriptor.Unknown)
{
valueText = "unknown";
}
else if (elem.ElementType == ElementType.UInt128 ||
elem.ElementType == ElementType.Int128)
{
valueText = BitConverter.ToString((byte[])elem.Value);
}
else
{
valueText = String.Format(System.Globalization.CultureInfo.InvariantCulture, "0x{0:X}", elem.Value);
}
}
if (name == null)
{
writer.WriteLine("{0}: {1}", elem.ElementType, valueText);
}
else
{
writer.WriteLine("{0}: {1} -- {2}", elem.ElementType, valueText, name);
}
}//else
}
private void WriteSByte(ServiceElement element, SByte value, byte[] buf, ref int offset, out int totalLength)
{
Byte valueU = unchecked((Byte)value);
WriteByte(element, valueU, buf, ref offset, out totalLength);
}
/// <summary>
/// Create the element in the buffer starting at offset, and return its totalLength.
/// </summary>
/// <param name="element">The element to create.
/// </param>
/// <param name="buf">The byte array to write the encoded element to.
/// </param>
/// <param name="offset">The place to start writing in <paramref name="buf"/>.
/// </param>
///
/// <returns>The total length of the encoded element written to the buffer
/// </returns>
protected virtual int CreateElement(ServiceElement element, byte[] buf, int offset)
{
int totalLength;
//
if (element.ElementTypeDescriptor == ElementTypeDescriptor.ElementSequence ||
element.ElementTypeDescriptor == ElementTypeDescriptor.ElementAlternative)
{
HeaderWriteState headerState;
int curLen;
curLen = MakeVariableLengthHeader(buf, offset, element.ElementTypeDescriptor, out headerState);
offset += curLen;
foreach (ServiceElement childElement in element.GetValueAsElementList())
{
curLen = CreateElement(childElement, buf, offset);
offset += curLen;
}//for
CompleteHeaderWrite(headerState, buf, offset, out totalLength);
//----------------
}
else if (element.ElementTypeDescriptor == ElementTypeDescriptor.UnsignedInteger ||
element.ElementTypeDescriptor == ElementTypeDescriptor.TwosComplementInteger)
{
switch (element.ElementType)
{
case ElementType.UInt8:
WriteByte(element, (Byte)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int8:
WriteSByte(element, (SByte)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.UInt16:
WriteUInt16(element, (UInt16)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int16:
WriteInt16(element, (Int16)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.UInt32:
WriteUInt32(element, (UInt32)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int32:
WriteInt32(element, (Int32)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.UInt64:
WriteUInt64(element, (UInt64)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int64:
WriteInt64(element, (Int64)element.Value, buf, ref offset, out totalLength);
break;
default:
System.Diagnostics.Debug.Fail(String.Format(System.Globalization.CultureInfo.InvariantCulture,
"Unexpected integral type '{0}'.", element.ElementType));
totalLength = 0;
break;
}//switch
//----------------
}
else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Uuid)
{
if (element.ElementType == ElementType.Uuid16)
{
WriteUInt16(element, (UInt16)element.Value, buf, ref offset, out totalLength);
}
else if (element.ElementType == ElementType.Uuid32)
{
WriteUInt32(element, (UInt32)element.Value, buf, ref offset, out totalLength);
}
else
{
//TODO If the 'Guid' holds a 'Bluetooth-based' UUID, then should we write the short form?
byte[] bytes;
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.Uuid128);
Guid hostGuid = (Guid)element.Value;
Guid netGuid = Sockets.BluetoothListener.HostToNetworkOrder(hostGuid);
bytes = netGuid.ToByteArray();
WriteFixedLength(element, bytes, buf, ref offset, out totalLength);
}
//----------------
}
else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Url)
{
Uri uri = element.GetValueAsUri();
String uriString = uri.ToString();
byte[] valueBytes = System.Text.Encoding.ASCII.GetBytes(uriString);
WriteVariableLength(element, valueBytes, buf, ref offset, out totalLength);
//----------------
}
else if (element.ElementTypeDescriptor == ElementTypeDescriptor.TextString)
{
byte[] valueBytes;
String valueString = element.Value as String;
if (valueString != null)
{
valueBytes = System.Text.Encoding.UTF8.GetBytes(valueString);
}
else
{
System.Diagnostics.Debug.Assert(element.Value is byte[]);
valueBytes = (byte[])element.Value;
}
WriteVariableLength(element, valueBytes, buf, ref offset, out totalLength);
//----------------
}
else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Nil)
{
WriteFixedLength(element, new byte[0], buf, ref offset, out totalLength);
//----------------
}
else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Boolean)
{
bool value = (bool)element.Value;
byte[] valueBytes = new byte[1];
valueBytes[0] = value ? (byte)1 : (byte)0;
WriteFixedLength(element, valueBytes, buf, ref offset, out totalLength);
//----------------
}
else
{
totalLength = 0;
}
//
if (totalLength == 0)
{
throw new NotSupportedException(String.Format(System.Globalization.CultureInfo.InvariantCulture,
"Creation of element type '{0}' not implemented.", element.ElementType));
}
return(totalLength);
}
private int CreateAttrId(ServiceAttributeId attrId, byte[] buf, int offset)
{
ServiceElement dummyElement
= new ServiceElement(
ElementType.UInt16, unchecked((UInt16)attrId));
return CreateElement(dummyElement, buf, offset);
}
/// <summary>
/// Get the enum-like class containing the Service Attribute Id definitions
/// for the type of the Service Class contained in the given
/// <see cref="F:InTheHand.Net.Bluetooth.AttributeIds.UniversalAttributeId.ServiceClassIdList"/>
/// (type <see cref="F:InTheHand.Net.Bluetooth.ElementTypeDescriptor.Uuid"/>) data element.
/// </summary>
/// -
/// <returns>
/// A <see cref="T:System.Type"/> object representing the enum-like class
/// holding the Attribute Id definitions, or null if the Service Class is
/// unknown or the element is not of <see cref="F:InTheHand.Net.Bluetooth.ElementTypeDescriptor.Uuid"/>
/// type.
/// </returns>
/// -
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="idElement"/> is null.
/// </exception>
protected virtual Type GetAttributeIdEnumType(ServiceElement idElement)
{
if (idElement == null) { throw new ArgumentNullException("idElement"); }
//
if (idElement.ElementTypeDescriptor != ElementTypeDescriptor.Uuid) {
return null;
}
Guid uuid = idElement.GetValueAsUuid();
//
return GetAttributeIdEnumType(uuid);
}
private static void DumpProtocolDescriptorListList(System.IO.TextWriter writer, int depth, ServiceElement element)
{
// The list.
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.ElementSequence);
WritePrefix(writer, depth);
writer.Write("( ");
bool firstLayer = true;
foreach (ServiceElement layer in element.GetValueAsElementList())
{
ServiceElement[] items = layer.GetValueAsElementArray();
int used = 0;
System.Diagnostics.Debug.Assert(items[used].ElementTypeDescriptor == ElementTypeDescriptor.Uuid);
Guid protoGuid = items[used].GetValueAsUuid();
String protoStr;
HackProtocolId proto = GuidToHackProtocolId(protoGuid, out protoStr);
//
used++;
writer.Write("{0}( {1}", (firstLayer ? string.Empty : ", "), protoStr);
if (proto == HackProtocolId.L2Cap)
{
if (used < items.Length)
{
System.Diagnostics.Debug.Assert(items[used].ElementType == ElementType.UInt16);
UInt16 u16 = (UInt16)items[used].Value;
HackProtocolServiceMultiplexer psm = unchecked ((HackProtocolServiceMultiplexer)u16);
used++;
writer.Write(", PSM={0}", Enum_ToStringNameOrHex(psm));
}
}
else if (proto == HackProtocolId.Rfcomm)
{
if (used < items.Length)
{
System.Diagnostics.Debug.Assert(items[used].ElementType == ElementType.UInt8);
byte channelNumber = (byte)items[used].Value;
used++;
writer.Write(", ChannelNumber={0}", channelNumber);
}
}
// Others include BNEP for instance, which isn't defined in the base SDP spec.
if (used < items.Length)
{
writer.Write(", ...");
}
writer.Write(" )");
firstLayer = false;
}//foreach layer
writer.WriteLine(" )");
}
private void WriteByte(ServiceElement element, Byte value, byte[] buf, ref int offset, out int totalLength)
{
byte[] valueBytes = new byte[1];
valueBytes[0] = value;
WriteFixedLength(element, valueBytes, buf, ref offset, out totalLength);
}
private void WriteFixedLength(ServiceElement element, byte[] valueBytes, byte[] buf, ref int offset, out int totalLength)
{
int headerLen = WriteHeaderFixedLength(element.ElementTypeDescriptor, valueBytes.Length, buf, offset, out totalLength);
offset += headerLen;
VerifyWriteSpaceRemaining(valueBytes.Length, buf, offset);
valueBytes.CopyTo(buf, offset);
System.Diagnostics.Debug.Assert(totalLength == headerLen + valueBytes.Length);
}
private void WriteByte(ServiceElement element, Byte value, byte[] buf, ref int offset, out int totalLength)
{
byte[] valueBytes = new byte[1];
valueBytes[0] = value;
WriteFixedLength(element, valueBytes, buf, ref offset, out totalLength);
}
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:InTheHand.Net.Bluetooth.ServiceAttribute"/> class.
/// </summary>
/// -
/// <param name="id">The Attribute Id as a <see cref="T:InTheHand.Net.Bluetooth.ServiceAttributeId"/>.</param>
/// <param name="value">The value as a <see cref="T:InTheHand.Net.Bluetooth.ServiceElement"/>.</param>
public ServiceAttribute(ServiceAttributeId id, ServiceElement value)
{
m_id = id;
m_element = value;
}
private static void DumpRawElement(System.IO.TextWriter writer, int depth, ServiceElement attr)
{
WritePrefix(writer, depth);
if (attr.ElementType == ElementType.ElementSequence
|| attr.ElementType == ElementType.ElementAlternative) {
writer.WriteLine("{0}", attr.ElementType);
foreach (ServiceElement element in attr.GetValueAsElementList()) {
DumpRawElement(writer, depth + 1, element);
}
} else if (attr.ElementType == ElementType.Nil) {
writer.WriteLine("Nil:");
} else if (attr.ElementType == ElementType.TextString
|| attr.ElementType == ElementType.Boolean
|| attr.ElementType == ElementType.Url) {
// Non-numeric types
writer.WriteLine("{0}: {1}", attr.ElementType, attr.Value);
} else if (attr.ElementType == ElementType.Uuid128) {
writer.WriteLine("{0}: ", attr.ElementType, attr.Value);
} else {
writer.WriteLine("{0}: 0x{1:X}", attr.ElementType, attr.Value);
//{catch(?FOrmatExptn){
// writer.WriteLine("{0}: 0x{1}", attr.Type, attr.Value);
//}
}
}
public ServiceElement[] GetValueAsElementArray()
{
IList_ServiceElement list = GetValueAsElementList();
ServiceElement[] arr = new ServiceElement[list.Count];
GetValueAsElementList().CopyTo(arr, 0);
return arr;
}
private static void DumpProtocolDescriptorList(System.IO.TextWriter writer, int depth, ServiceElement element)
{
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.ElementAlternative
|| element.ElementType == ElementType.ElementSequence);
//
// If passes a list of alternatives, each a protocol descriptor list,
// then call ourselves on each list.
if (element.ElementType == ElementType.ElementAlternative) {
foreach (ServiceElement curStack in element.GetValueAsElementList()) {
DumpProtocolDescriptorListList(writer, depth + 1, curStack);
}//foreach
return;
}
//else
DumpProtocolDescriptorListList(writer, depth, element);
}
[CLSCompliant(false)] // instead use .ctor(ServiceAttributeId,AttributeValue).
public ServiceAttribute(UInt16 id, ServiceElement value)
: this(unchecked((ServiceAttributeId)(Int16)id), value)
{ }
private static void DumpString(System.IO.TextWriter writer, int depth, ServiceElement element, LanguageBaseItem langBase)
{
if (langBase != null) {
try {
String value = element.GetValueAsString(langBase);
writer.WriteLine("{0}: [{1}] '{2}'", element.ElementType, langBase.NaturalLanguage, value);
} catch (NotSupportedException ex) {
System.Diagnostics.Debug.Assert(ex.Message != null);
System.Diagnostics.Debug.Assert(ex.Message.StartsWith("Unrecognized character encoding"));
writer.WriteLine("{0}: Failure: {1}", element.ElementType, ex.Message);
}
} else {
try {
String hack = element.GetValueAsStringUtf8();
writer.WriteLine("{0} (guessing UTF-8): '{1}'", element.ElementType, hack);
} catch (
// TODO ! What exception thrown by UTF8Encoding on NETCF?
#if ! WinCE
System.Text.DecoderFallbackException
#else
// NETCF doesn't support DecoderFallbackException this what the docs say.
ArgumentException
#endif
) {
writer.WriteLine("{0} (Unknown/bad encoding):", element.ElementType);
}//try
}
}
private void WriteSByte(ServiceElement element, SByte value, byte[] buf, ref int offset, out int totalLength)
{
Byte valueU = unchecked ((Byte)value);
WriteByte(element, valueU, buf, ref offset, out totalLength);
}
private void WriteInt32(ServiceElement element, Int32 value, byte[] buf, ref int offset, out int totalLength)
{
Int32 host32 = value;
Int32 net32 = IPAddress.HostToNetworkOrder(host32);
byte[] valueBytes = BitConverter.GetBytes(net32);
WriteFixedLength(element, valueBytes, buf, ref offset, out totalLength);
}
//--------------------------------------------------------------
private static ServiceRecord CreateRecord()
{
List_ServiceAttribute attrs = new List_ServiceAttribute();
ServiceElement element;
//
element = new ServiceElement(ElementType.ElementSequence,
new ServiceElement(ElementType.Uuid128, Guid.Empty));
attrs.Add(new ServiceAttribute(UniversalAttributeId.ServiceClassIdList, element));
//
element = ServiceRecordHelper.CreateRfcommProtocolDescriptorList();
attrs.Add(new ServiceAttribute(UniversalAttributeId.ProtocolDescriptorList, element));
//
ServiceRecord record = new ServiceRecord(attrs);
return record;
}
private void WriteUInt64(ServiceElement element, UInt64 value, byte[] buf, ref int offset, out int totalLength)
{
Int64 valueS = unchecked ((Int64)value);
WriteInt64(element, valueS, buf, ref offset, out totalLength);
}
//--------
private static void DumpAdditionalProtocolDescriptorLists(System.IO.TextWriter writer, int depth, ServiceElement element)
{
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.ElementSequence);
//
// Is a list of PDLs
foreach (ServiceElement curList in element.GetValueAsElementList()) {
DumpProtocolDescriptorList(writer, depth + 1, curList);
}//foreach
}
private static ElementType checkTypeSuitsElementParamsArray(ElementType typePassThru, ServiceElement[] childElements)
{
// Throw a more specific error about the params array when the value is null.
// As error would be thrown by SetValue, but we can report a more helpful message.
if (childElements == null) {
// Caller passed a literal null, so could be aiming for other ElementType
// so can't complain that we need to be a Seq/Alt type.
} else {
//
if (typePassThru != ElementType.ElementSequence && typePassThru != ElementType.ElementAlternative) {
throw new ArgumentException(ErrorMsgSeqAltTypeNeedElementArray);
}
}
return typePassThru;
}
private static void DumpProtocolDescriptorListList(System.IO.TextWriter writer, int depth, ServiceElement element)
{
// The list.
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.ElementSequence);
WritePrefix(writer, depth);
writer.Write("( ");
bool firstLayer = true;
foreach (ServiceElement layer in element.GetValueAsElementList()) {
ServiceElement[] items = layer.GetValueAsElementArray();
int used = 0;
System.Diagnostics.Debug.Assert(items[used].ElementTypeDescriptor == ElementTypeDescriptor.Uuid);
Guid protoGuid = items[used].GetValueAsUuid();
HackProtocolId proto = GuidToHackProtocolId(protoGuid);
String protoStr;
if (proto != 0) {
protoStr = Enum_ToStringNameOrHex(proto);
} else { // Not a standard Bluetooth value so dump its UUID
protoStr = protoGuid.ToString();
}
//
used++;
writer.Write("{0}( {1}", (firstLayer ? string.Empty : ", "), protoStr);
if (proto == HackProtocolId.L2Cap) {
if (used < items.Length) {
System.Diagnostics.Debug.Assert(items[used].ElementType == ElementType.UInt16);
HackProtocolServiceMultiplexer psm = (HackProtocolServiceMultiplexer)(UInt16)items[used].Value;
used++;
writer.Write(", PSM={0}", Enum_ToStringNameOrHex(psm));
}
} else if (proto == HackProtocolId.Rfcomm) {
if (used < items.Length) {
System.Diagnostics.Debug.Assert(items[used].ElementType == ElementType.UInt8);
byte channelNumber = (byte)items[used].Value;
used++;
writer.Write(", ChannelNumber={0}", channelNumber);
}
}
// Others include BNEP for instance, which isn't defined in the base SDP spec.
if (used < items.Length) {
writer.Write(", ...");
}
writer.Write(" )");
firstLayer = false;
}//foreach layer
writer.WriteLine(" )");
}
//--------
private static void DumpAdditionalProtocolDescriptorLists(System.IO.TextWriter writer, int depth, ServiceElement element)
{
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.ElementSequence);
//
// Is a list of PDLs
foreach (ServiceElement curList in element.GetValueAsElementList())
{
DumpProtocolDescriptorList(writer, depth + 1, curList);
}//foreach
}
private static void DumpElement(System.IO.TextWriter writer, int depth, ServiceElement attr)
{
WritePrefix(writer, depth);
if (attr.ElementType == ElementType.ElementSequence || attr.ElementType == ElementType.ElementAlternative) {
writer.WriteLine("{0}", attr.ElementType);
foreach (ServiceElement element in attr.GetValueAsElementList()) {
DumpElement(writer, depth + 1, element);
}//for
} else if (attr.ElementType == ElementType.Nil) {
writer.WriteLine("Nil:");
} else if (attr.ElementType == ElementType.TextString
|| attr.ElementType == ElementType.Boolean
|| attr.ElementType == ElementType.Url) {
// Non-numeric types
writer.WriteLine("{0}: {1}", attr.ElementType, attr.Value);
} else {
String name = null;
String valueText = null;
if (attr.ElementTypeDescriptor == ElementTypeDescriptor.Uuid) {
if (attr.ElementType == ElementType.Uuid16) {
name = BluetoothService.GetName((UInt16)attr.Value);
} else if (attr.ElementType == ElementType.Uuid32) {
name = BluetoothService.GetName((UInt32)attr.Value);
} else {
System.Diagnostics.Debug.Assert(attr.ElementType == ElementType.Uuid128);
name = BluetoothService.GetName((Guid)attr.Value);
valueText = ((Guid)attr.Value).ToString();
}
}//if UUID
if (valueText == null) {
if (attr.ElementTypeDescriptor == ElementTypeDescriptor.Unknown) {
valueText = "unknown";
} else {
valueText = String.Format(System.Globalization.CultureInfo.InvariantCulture, "0x{0:X}", attr.Value);
}
}
if (name == null) {
writer.WriteLine("{0}: {1}", attr.ElementType, valueText);
} else {
writer.WriteLine("{0}: {1} -- {2}", attr.ElementType, valueText, name);
}
}//else
}
private static void DumpProtocolDescriptorList(System.IO.TextWriter writer, int depth, ServiceElement element)
{
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.ElementAlternative ||
element.ElementType == ElementType.ElementSequence);
//
// If passes a list of alternatives, each a protocol descriptor list,
// then call ourselves on each list.
if (element.ElementType == ElementType.ElementAlternative)
{
foreach (ServiceElement curStack in element.GetValueAsElementList())
{
DumpProtocolDescriptorListList(writer, depth + 1, curStack);
}//foreach
return;
}
//else
DumpProtocolDescriptorListList(writer, depth, element);
}
private static ServiceElement CreatePdlLayer(UInt16 uuid, params ServiceElement[] data)
{
IList_ServiceElement curSeqChildren;
ServiceElement curValueElmt, curSeqElmt;
//
curSeqChildren = new List_ServiceElement();
curValueElmt = new ServiceElement(ElementType.Uuid16, uuid);
curSeqChildren.Add(curValueElmt);
foreach (ServiceElement element in data) {
curSeqChildren.Add(element);
}
curSeqElmt = new ServiceElement(ElementType.ElementSequence, curSeqChildren);
return curSeqElmt;
}
private int CreateElement(ServiceElement element, byte[] buf, int offset)
{
int totalLength;
//
if (element.ElementTypeDescriptor == ElementTypeDescriptor.ElementSequence
|| element.ElementTypeDescriptor == ElementTypeDescriptor.ElementAlternative) {
HeaderWriteState headerState;
int curLen;
curLen = MakeVariableLengthHeader(buf, offset, element.ElementTypeDescriptor, out headerState);
offset += curLen;
foreach (ServiceElement childElement in element.GetValueAsElementList()) {
curLen = CreateElement(childElement, buf, offset);
offset += curLen;
}//for
CompleteHeaderWrite(headerState, buf, offset, out totalLength);
//----------------
} else if (element.ElementTypeDescriptor == ElementTypeDescriptor.UnsignedInteger
|| element.ElementTypeDescriptor == ElementTypeDescriptor.TwosComplementInteger) {
switch (element.ElementType) {
case ElementType.UInt8:
WriteByte(element, (Byte)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int8:
WriteSByte(element, (SByte)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.UInt16:
WriteUInt16(element, (UInt16)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int16:
WriteInt16(element, (Int16)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.UInt32:
WriteUInt32(element, (UInt32)element.Value, buf, ref offset, out totalLength);
break;
case ElementType.Int32:
WriteInt32(element, (Int32)element.Value, buf, ref offset, out totalLength);
break;
default:
System.Diagnostics.Debug.Fail(String.Format(System.Globalization.CultureInfo.InvariantCulture,
"Unexpected integral type '{0}'.", element.ElementType));
totalLength = 0;
break;
}//switch
//----------------
} else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Uuid) {
if (element.ElementType == ElementType.Uuid16) {
WriteUInt16(element, (UInt16)element.Value, buf, ref offset, out totalLength);
} else if (element.ElementType == ElementType.Uuid32) {
WriteUInt32(element, (UInt32)element.Value, buf, ref offset, out totalLength);
} else {
//TODO If the 'Guid' holds a 'Bluetooth-based' UUID, then should we write the short form?
byte[] bytes;
System.Diagnostics.Debug.Assert(element.ElementType == ElementType.Uuid128);
Guid hostGuid = (Guid)element.Value;
Guid netGuid = Sockets.BluetoothListener.HostToNetworkOrder(hostGuid);
bytes = netGuid.ToByteArray();
WriteFixedLength(element, bytes, buf, ref offset, out totalLength);
}
//----------------
} else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Url) {
Uri uri = element.GetValueAsUri();
String uriString = uri.ToString();
byte[] valueBytes = System.Text.Encoding.ASCII.GetBytes(uriString);
WriteVariableLength(element, valueBytes, buf, ref offset, out totalLength);
//----------------
} else if (element.ElementTypeDescriptor == ElementTypeDescriptor.TextString) {
byte[] valueBytes;
String valueString = element.Value as String;
if (valueString != null) {
valueBytes = System.Text.Encoding.UTF8.GetBytes(valueString);
} else {
System.Diagnostics.Debug.Assert(element.Value is byte[]);
valueBytes = (byte[])element.Value;
}
WriteVariableLength(element, valueBytes, buf, ref offset, out totalLength);
//----------------
} else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Nil) {
WriteFixedLength(element, new byte[0], buf, ref offset, out totalLength);
//----------------
} else if (element.ElementTypeDescriptor == ElementTypeDescriptor.Boolean) {
bool value = (bool)element.Value;
byte[] valueBytes = new byte[1];
valueBytes[0] = value ? (byte)1 : (byte)0;
WriteFixedLength(element, valueBytes, buf, ref offset, out totalLength);
//----------------
} else {
totalLength = 0;
}
//
if (totalLength == 0) {
throw new NotSupportedException(String.Format(System.Globalization.CultureInfo.InvariantCulture,
"Creation of element type '{0}' not implemented.", element.ElementType));
}
return totalLength;
}
