private void ChangeTriggered(UPnPStateVariable sender, object value)
{
//Console.WriteLine("LastChange from {0}", UUID);
var newState = sender.Value;
//Console.WriteLine(newState);
ParseChangeXML((string)newState);
}
private void OnZoneGroupStateChanged(UPnPStateVariable sender, object newvalue)
{
Console.WriteLine(sender.Value);
// Avoid multiple state changes and consolidate them
if (stateChangedTimer != null)
stateChangedTimer.Dispose();
stateChangedTimer = new Timer((state) => HandleZoneXML(sender.Value.ToString()), null, TimeSpan.FromMilliseconds(700),
TimeSpan.FromMilliseconds(-1));
}
protected UPnPService BuildUPnPService()
{
UPnPStateVariable[] RetVal = new UPnPStateVariable[20];
RetVal[0] = new UPnPModeratedStateVariable("ContainerUpdateIDs", typeof(System.String), true);
RetVal[1] = new UPnPModeratedStateVariable("A_ARG_TYPE_Index", typeof(System.UInt32), false);
RetVal[1].AddAssociation("Browse", "StartingIndex");
RetVal[1].AddAssociation("Search", "StartingIndex");
RetVal[2] = new UPnPModeratedStateVariable("A_ARG_TYPE_UpdateID", typeof(System.UInt32), false);
RetVal[2].AddAssociation("Browse", "UpdateID");
RetVal[2].AddAssociation("Search", "UpdateID");
RetVal[3] = new UPnPModeratedStateVariable("SystemUpdateID", typeof(System.UInt32), true);
RetVal[3].AddAssociation("GetSystemUpdateID", "Id");
RetVal[4] = new UPnPModeratedStateVariable("SearchCapabilities", typeof(System.String), false);
RetVal[4].AddAssociation("GetSearchCapabilities", "SearchCaps");
RetVal[5] = new UPnPModeratedStateVariable("A_ARG_TYPE_Result", typeof(System.String), false);
RetVal[5].AddAssociation("Browse", "Result");
RetVal[5].AddAssociation("CreateObject", "Elements");
RetVal[5].AddAssociation("CreateObject", "Result");
RetVal[5].AddAssociation("Search", "Result");
RetVal[6] = new UPnPModeratedStateVariable("A_ARG_TYPE_Count", typeof(System.UInt32), false);
RetVal[6].AddAssociation("Browse", "RequestedCount");
RetVal[6].AddAssociation("Browse", "NumberReturned");
RetVal[6].AddAssociation("Browse", "TotalMatches");
RetVal[6].AddAssociation("Search", "RequestedCount");
RetVal[6].AddAssociation("Search", "NumberReturned");
RetVal[6].AddAssociation("Search", "TotalMatches");
RetVal[7] = new UPnPModeratedStateVariable("A_ARG_TYPE_ObjectID", typeof(System.String), false);
RetVal[7].AddAssociation("Browse", "ObjectID");
RetVal[7].AddAssociation("CreateObject", "ContainerID");
RetVal[7].AddAssociation("CreateObject", "ObjectID");
RetVal[7].AddAssociation("CreateReference", "ContainerID");
RetVal[7].AddAssociation("CreateReference", "ObjectID");
RetVal[7].AddAssociation("CreateReference", "NewID");
RetVal[7].AddAssociation("DestroyObject", "ObjectID");
RetVal[7].AddAssociation("Search", "ContainerID");
RetVal[7].AddAssociation("UpdateObject", "ObjectID");
RetVal[8] = new UPnPModeratedStateVariable("A_ARG_TYPE_SearchCriteria", typeof(System.String), false);
RetVal[8].AddAssociation("Search", "SearchCriteria");
RetVal[9] = new UPnPModeratedStateVariable("A_ARG_TYPE_TransferTotal", typeof(System.String), false);
RetVal[9].AddAssociation("GetTransferProgress", "TransferTotal");
RetVal[10] = new UPnPModeratedStateVariable("A_ARG_TYPE_Filter", typeof(System.String), false);
RetVal[10].AddAssociation("Browse", "Filter");
RetVal[10].AddAssociation("Search", "Filter");
RetVal[11] = new UPnPModeratedStateVariable("A_ARG_TYPE_SortCriteria", typeof(System.String), false);
RetVal[11].AddAssociation("Browse", "SortCriteria");
RetVal[11].AddAssociation("Search", "SortCriteria");
RetVal[12] = new UPnPModeratedStateVariable("A_ARG_TYPE_BrowseFlag", typeof(System.String), false);
RetVal[12].AllowedStringValues = new string[2]{"BrowseMetadata", "BrowseDirectChildren"};
RetVal[12].AddAssociation("Browse", "BrowseFlag");
RetVal[13] = new UPnPModeratedStateVariable("A_ARG_TYPE_TransferID", typeof(System.UInt32), false);
RetVal[13].AddAssociation("ExportResource", "TransferID");
RetVal[13].AddAssociation("GetTransferProgress", "TransferID");
RetVal[13].AddAssociation("ImportResource", "TransferID");
RetVal[13].AddAssociation("StopTransferResource", "TransferID");
RetVal[14] = new UPnPModeratedStateVariable("A_ARG_TYPE_TransferLength", typeof(System.String), false);
RetVal[14].AddAssociation("GetTransferProgress", "TransferLength");
RetVal[15] = new UPnPModeratedStateVariable("A_ARG_TYPE_TagValueList", typeof(System.String), false);
RetVal[15].AddAssociation("UpdateObject", "CurrentTagValue");
RetVal[15].AddAssociation("UpdateObject", "NewTagValue");
RetVal[16] = new UPnPModeratedStateVariable("A_ARG_TYPE_TransferStatus", typeof(System.String), false);
RetVal[16].AllowedStringValues = new string[4]{"COMPLETED", "ERROR", "IN_PROGRESS", "STOPPED"};
RetVal[16].AddAssociation("GetTransferProgress", "TransferStatus");
RetVal[17] = new UPnPModeratedStateVariable("A_ARG_TYPE_URI", typeof(System.Uri), false);
RetVal[17].AddAssociation("DeleteResource", "ResourceURI");
RetVal[17].AddAssociation("ExportResource", "SourceURI");
RetVal[17].AddAssociation("ExportResource", "DestinationURI");
RetVal[17].AddAssociation("ImportResource", "SourceURI");
RetVal[17].AddAssociation("ImportResource", "DestinationURI");
RetVal[18] = new UPnPModeratedStateVariable("TransferIDs", typeof(System.String), true);
RetVal[19] = new UPnPModeratedStateVariable("SortCapabilities", typeof(System.String), false);
RetVal[19].AddAssociation("GetSortCapabilities", "SortCaps");
UPnPService S = new UPnPService(1, "urn:schemas-upnp-org:service:ContentDirectory", URN, true, this);
for(int i=0;i<RetVal.Length;++i)
{
S.AddStateVariable(RetVal[i]);
}
S.AddMethod("Browse");
S.AddMethod("CreateObject");
S.AddMethod("CreateReference");
S.AddMethod("DeleteResource");
S.AddMethod("DestroyObject");
S.AddMethod("ExportResource");
S.AddMethod("GetSearchCapabilities");
S.AddMethod("GetSortCapabilities");
S.AddMethod("GetSystemUpdateID");
S.AddMethod("GetTransferProgress");
S.AddMethod("ImportResource");
S.AddMethod("Search");
S.AddMethod("StopTransferResource");
S.AddMethod("UpdateObject");
return(S);
}
private void OnModifiedSink_SystemUpdateID(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_SystemUpdateID != null) OnStateVariableModified_SystemUpdateID(this);
}
private void OnModifiedSink_ContainerUpdateIDs(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_ContainerUpdateIDs != null) OnStateVariableModified_ContainerUpdateIDs(this);
}
private void OnModifiedSink_A_ARG_TYPE_TransferTotal(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_A_ARG_TYPE_TransferTotal != null) OnStateVariableModified_A_ARG_TYPE_TransferTotal(this);
}
private void ParseStateVarXml(String evented, String multicasted, XmlTextReader XMLDoc)
{
// if (XML=="")
// {
// return;
// }
string ComplexType = "";
string ComplexTypeNS = "";
UPnPComplexType CT = null;
DText P = new DText();
P.ATTRMARK = ":";
string minval = null;
string maxval = null;
string stepval = null;
bool HasDef = false;
string name = "";
string DataType = "";
string DefaultValue = null;
ArrayList allowedValueList = new ArrayList();
string LocalName = "";
string lname2 = "";
// StringReader MyString = new StringReader(XML);
// XmlTextReader XMLDoc = new XmlTextReader(MyString);
// XMLDoc.Read();
// XMLDoc.MoveToContent();
bool done = false;
while (!done && XMLDoc.Read())
{
switch (XMLDoc.NodeType)
{
case XmlNodeType.Element:
LocalName = XMLDoc.LocalName;
switch (XMLDoc.LocalName)
{
case "dataType":
if (XMLDoc.HasAttributes)
{
for (int i = 0; i < XMLDoc.AttributeCount; i++)
{
XMLDoc.MoveToAttribute(i);
if (XMLDoc.LocalName == "type")
{
P[0] = XMLDoc.Value;
if (P.DCOUNT() == 1)
{
ComplexType = P[1];
}
else
{
ComplexType = P[2];
ComplexTypeNS = P[1];
}
CT = (UPnPComplexType)ComplexTypeTable[ComplexType + ":" + XMLDoc.LookupNamespace(ComplexTypeNS)];
}
}
}
break;
case "allowedValueList":
bool done2 = false;
while (!done2 && XMLDoc.Read())
{
switch (XMLDoc.NodeType)
{
case XmlNodeType.Element:
lname2 = XMLDoc.LocalName;
break;
case XmlNodeType.EndElement:
if (XMLDoc.LocalName == "allowedValueList")
{
done2 = true;
}
break;
case XmlNodeType.Text:
if (lname2 == "allowedValue")
{
allowedValueList.Add(XMLDoc.Value);
}
break;
}
}
break;
case "allowedValueRange":
bool done3 = false;
while (!done3 && XMLDoc.Read())
{
switch (XMLDoc.NodeType)
{
case XmlNodeType.Element:
lname2 = XMLDoc.LocalName;
break;
case XmlNodeType.EndElement:
if (XMLDoc.LocalName == "allowedValueRange")
{
done3 = true;
}
break;
case XmlNodeType.Text:
switch (lname2)
{
case "minimum":
minval = XMLDoc.Value;
break;
case "maximum":
maxval = XMLDoc.Value;
break;
case "step":
stepval = XMLDoc.Value;
break;
}
break;
}
}
break;
}
break;
case XmlNodeType.EndElement:
if (XMLDoc.LocalName == "stateVariable")
{
done = true;
}
break;
case XmlNodeType.Text:
switch (LocalName)
{
case "name":
name = XMLDoc.Value.Trim();
break;
case "dataType":
DataType = XMLDoc.Value.Trim();
break;
case "defaultValue":
DefaultValue = XMLDoc.Value;
HasDef = true;
break;
}
break;
}
}
UPnPStateVariable var;
if (CT == null)
{
var = new UPnPStateVariable(name);
}
else
{
var = new UPnPStateVariable(name, CT);
}
var.ParentService = this;
if (evented == "yes")
{
var.SendEvent = true;
}
if (multicasted == "yes")
{
var.MulticastEvent = true;
}
var.VarType = DataType;
if (allowedValueList.Count > 0)
{
var.AllowedStringValues = (string[])allowedValueList.ToArray(typeof(string));
}
if (HasDef)
{
var.DefaultValue = UPnPService.CreateObjectInstance(var.GetNetType(), DefaultValue);
}
if ((minval != null) && (maxval != null))
{
Object stepobj = null;
if (stepval != null)
{
try
{
stepobj = UPnPService.CreateObjectInstance(var.GetNetType(), stepval);
}
catch (Exception)
{
stepobj = null;
}
}
object MIN;
object MAX;
try
{
MIN = UPnPService.CreateObjectInstance(var.GetNetType(), minval);
}
catch (Exception)
{
FieldInfo mi = var.GetNetType().GetField("MinValue");
MIN = mi.GetValue(null);
}
try
{
MAX = UPnPService.CreateObjectInstance(var.GetNetType(), maxval);
}
catch (Exception)
{
FieldInfo mi = var.GetNetType().GetField("MaxValue");
MAX = mi.GetValue(null);
}
var.SetRange(MIN,
MAX,
stepobj);
}
//StateVariables.Add(name,var);
StateVariables[name] = var; // TempPatch Only
/*
IDictionaryEnumerator en = RemoteMethods.GetEnumerator();
UPnPAction a;
while(en.MoveNext())
{
a = (UPnPAction)en.Value;
for(int x =0;x<a.ArgumentList.Length;++x)
{
if (a.ArgumentList[x].RelatedStateVar.Name == name)
{
a.ArgumentList[x].RelatedStateVar.VarType = DataType;
a.ArgumentList[x].RelatedStateVar.AllowedStringValues = var.AllowedStringValues;
a.ArgumentList[x].RelatedStateVar.DefaultValue = DefaultValue;
}
}
}*/
}
internal void SendEvents(UPnPStateVariable V)
{
//IDictionaryEnumerator en = SubscriberTable.GetEnumerator();
SubscriberInfo sinfo;
HTTPMessage Packet;
Uri[] EventURLS;
ICollection en = SubscriberTable.Keys;
String[] KEYS = new String[en.Count];
HTTPRequest R;
en.CopyTo(KEYS, 0);
for (int keyid = 0; keyid < KEYS.Length; ++keyid)
{
object _tobj = SubscriberTable[KEYS[keyid]];
if (_tobj != null)
{
sinfo = (SubscriberInfo)_tobj;
if ((sinfo.Expires > DateTime.Now.Ticks) || (sinfo.Expires == -1))
{
EventURLS = ParseEventURL(sinfo.CallbackURL);
for (int x = 0; x < EventURLS.Length; ++x)
{
try
{
IPAddress dest = IPAddress.Parse(EventURLS[x].Host);
Packet = new HTTPMessage();
Packet.Directive = "NOTIFY";
Packet.AddTag("Content-Type", "text/xml");
Packet.AddTag("NT", "upnp:event");
Packet.AddTag("NTS", "upnp:propchange");
Packet.BodyBuffer = BuildEventXML(new UPnPStateVariable[1] { V });
Packet.DirectiveObj = HTTPMessage.UnEscapeString(EventURLS[x].PathAndQuery);
if (dest.AddressFamily == AddressFamily.InterNetwork) Packet.AddTag("Host", EventURLS[x].Host + ":" + EventURLS[x].Port.ToString());
if (dest.AddressFamily == AddressFamily.InterNetworkV6) Packet.AddTag("Host", "[" + RemoveIPv6Scope(EventURLS[x].Host) + "]:" + EventURLS[x].Port.ToString());
Packet.AddTag("SID", sinfo.SID);
Packet.AddTag("SEQ", sinfo.SEQ.ToString());
Packet.AddTag("CONNECTION", "close");
++sinfo.SEQ;
SubscriberTable[KEYS[keyid]] = sinfo;
//OpenSource.Utilities.EventLogger.Log(this,System.Diagnostics.EventLogEntryType.SuccessAudit,Packet.StringBuffer);
R = new HTTPRequest();
SendEventTable[R] = R;
R.OnResponse += new HTTPRequest.RequestHandler(HandleSendEvent);
R.PipelineRequest(new IPEndPoint(IPAddress.Parse(EventURLS[x].Host), EventURLS[x].Port), Packet, null);
}
catch (Exception)
{
}
}
}
else
{
SubscriberTable.Remove(sinfo.SID);
}
}
}
}
private void OnModifiedSink_RedVideoBlackLevel(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_RedVideoBlackLevel != null) OnStateVariableModified_RedVideoBlackLevel(this);
}
private void OnModifiedSink_Contrast(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_Contrast != null) OnStateVariableModified_Contrast(this);
}
private void OnModifiedSink_VolumeDB(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_VolumeDB != null) OnStateVariableModified_VolumeDB(this);
}
private void OnModifiedSink_ColorTemperature(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_ColorTemperature != null) OnStateVariableModified_ColorTemperature(this);
}
private void OnModifiedSink_PresetNameList(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_PresetNameList != null) OnStateVariableModified_PresetNameList(this);
}
private void OnModifiedSink_Mute(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_Mute != null) OnStateVariableModified_Mute(this);
}
private void OnModifiedSink_HorizontalKeystone(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_HorizontalKeystone != null) OnStateVariableModified_HorizontalKeystone(this);
}
/// <summary>
/// Retrieves all StateVariables in this Service
/// </summary>
/// <returns>Array of StateVariables</returns>
public UPnPStateVariable[] GetStateVariables()
{
UPnPStateVariable[] RetVal = new UPnPStateVariable[StateVariables.Count];
if (StateVariables.Count == 0) return RetVal;
IDictionaryEnumerator en = StateVariables.GetEnumerator();
int id = 0;
while (en.MoveNext())
{
RetVal[id] = (UPnPStateVariable)en.Value;
++id;
}
return RetVal;
}
/// <summary>
/// Remove a UPnPStateVariable
/// <para>
/// An exception will be thrown if you try to remove a UPnPStateVariable that is associated with an action,
/// or a UPnPStateVariable that is referenced by an Action.
/// </para>
/// </summary>
/// <param name="stateVariable">UPnPStateVariable to remove</param>
public void RemoveStateVariable(UPnPStateVariable stateVariable)
{
foreach (UPnPStateVariable.AssociationNode n in stateVariable.GetAssociations())
{
try
{
if (GetAction(n.ActionName).GetArg(n.ArgName).StateVarName == stateVariable.Name)
{
throw (new UPnPStateVariable.CannotRemoveException("Associated with " + n.ActionName + ":" + n.ArgName));
}
}
catch (System.NullReferenceException)
{ }
}
StateVariables.Remove(stateVariable.Name);
}
private void OnModifiedSink_BlueVideoGain(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_BlueVideoGain != null) OnStateVariableModified_BlueVideoGain(this);
}
private byte[] BuildEventXML(UPnPStateVariable[] vars)
{
MemoryStream ms = new MemoryStream();
XmlTextWriter XMLDoc = new XmlTextWriter(ms, System.Text.Encoding.UTF8);
XMLDoc.Formatting = System.Xml.Formatting.Indented;
XMLDoc.Indentation = 3;
string prefix = "e";
string ns = "urn:schemas-upnp-org:event-1-0";
XMLDoc.WriteStartDocument();
XMLDoc.WriteStartElement(prefix, "propertyset", ns);
foreach (UPnPStateVariable SVar in vars)
{
SVar.BuildProperty(prefix, ns, XMLDoc);
}
XMLDoc.WriteEndElement();
XMLDoc.WriteEndDocument();
XMLDoc.Flush();
byte[] RetVal = new byte[ms.Length - 3];
ms.Seek(3, SeekOrigin.Begin);
ms.Read(RetVal, 0, RetVal.Length);
XMLDoc.Close();
return (RetVal);
}
private void OnModifiedSink_Sharpness(UPnPStateVariable sender, object NewValue)
{
if(OnStateVariableModified_Sharpness != null) OnStateVariableModified_Sharpness(this);
}
private void OnModifiedSink_A_ARG_TYPE_SearchCriteria(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_A_ARG_TYPE_SearchCriteria != null) OnStateVariableModified_A_ARG_TYPE_SearchCriteria(this);
}
protected void LastChange_ModifiedSink(UPnPStateVariable Var, object NewValue)
{
OnStateVariable_LastChange_Event.Fire(this, (System.String)NewValue);
}
private void OnModifiedSink_A_ARG_TYPE_URI(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_A_ARG_TYPE_URI != null) OnStateVariableModified_A_ARG_TYPE_URI(this);
}
protected void CurrentConnectionIDs_ModifiedSink(UPnPStateVariable Var, object NewValue)
{
if(OnStateVariable_CurrentConnectionIDs != null) OnStateVariable_CurrentConnectionIDs((System.String)NewValue);
WeakReference[] w = (WeakReference[])WeakList_CurrentConnectionIDs.ToArray(typeof(WeakReference));
foreach(WeakReference wr in w)
{
if(wr.IsAlive==true)
{
((StateVariableModifiedHandler_CurrentConnectionIDs)wr.Target)((System.String)NewValue);
}
else
{
WeakList_CurrentConnectionIDs.Remove(wr);
}
}
}
private void OnModifiedSink_SortCapabilities(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_SortCapabilities != null) OnStateVariableModified_SortCapabilities(this);
}
protected void SourceProtocolInfo_ModifiedSink(UPnPStateVariable Var, object NewValue)
{
if(OnStateVariable_SourceProtocolInfo != null) OnStateVariable_SourceProtocolInfo((System.String)NewValue);
WeakReference[] w = (WeakReference[])WeakList_SourceProtocolInfo.ToArray(typeof(WeakReference));
foreach(WeakReference wr in w)
{
if(wr.IsAlive==true)
{
((StateVariableModifiedHandler_SourceProtocolInfo)wr.Target)((System.String)NewValue);
}
else
{
WeakList_SourceProtocolInfo.Remove(wr);
}
}
}
private void OnModifiedSink_TransferIDs(UPnPStateVariable sender, object NewValue)
{
if (OnStateVariableModified_TransferIDs != null) OnStateVariableModified_TransferIDs(this);
}
/// <summary>
/// Add a method to expose in this service
/// </summary>
/// <param name="MethodName">The name of the method to expose</param>
public void AddMethod(String MethodName)
{
string retname = "_ReturnValue";
UPnPStateVariable[] ESV;
bool DontCreate = false;
ESV = this.GetStateVariables();
UPnPStateVariable sv;
MethodInfo minfo = ServiceInstance.GetType().GetMethod(MethodName);
if (minfo == null)
{
throw (new Exception(MethodName + " does not exist in " + ServiceInstance.GetType().ToString()));
}
// Create Generic State Variables
DontCreate = false;
if (minfo.ReturnType.FullName != "System.Void")
{
if (minfo.GetCustomAttributes(true).Length > 0)
{
foreach (Attribute a in minfo.GetCustomAttributes(true))
{
if (a.GetType() == typeof(OpenSource.UPnP.ReturnArgumentAttribute))
{
retname = ((ReturnArgumentAttribute)a).Name;
break;
}
}
}
// There is a return value
sv = new UPnPStateVariable("A_ARG_TYPE_" + MethodName + "_RetType", minfo.ReturnType, false);
sv.AddAssociation(MethodName, retname);
foreach (UPnPStateVariable _ESV in ESV)
{
foreach (UPnPStateVariable.AssociationNode AESV in _ESV.GetAssociations())
{
if ((AESV.ActionName == MethodName) && (AESV.ArgName == retname))
{
// Don't create state variable
DontCreate = true;
}
}
}
if (DontCreate == false) this.AddStateVariable(sv);
}
ParameterInfo[] pinfo = minfo.GetParameters();
for (int x = 0; x < pinfo.Length; ++x)
{
sv = new UPnPStateVariable("A_ARG_TYPE_" + MethodName + "_" + pinfo[x].Name, pinfo[x].ParameterType, false);
sv.AddAssociation(MethodName, pinfo[x].Name);
DontCreate = false;
foreach (UPnPStateVariable _ESV in ESV)
{
foreach (UPnPStateVariable.AssociationNode AESV in _ESV.GetAssociations())
{
if ((AESV.ActionName == MethodName) && (AESV.ArgName == pinfo[x].Name))
{
// Don't create state variable
DontCreate = true;
}
}
}
if (DontCreate == false) this.AddStateVariable(sv);
}
UPnPAction NewAction = new UPnPAction();
NewAction.Name = MethodName;
NewAction.ParentService = this;
NewAction.MethodPointer = minfo;
UPnPArgument ARG;
if (minfo.ReturnType.FullName != "System.Void")
{
ARG = new UPnPArgument(retname, "");
ARG.DataType = UPnPStateVariable.ConvertToUPnPType(minfo.ReturnType);
ARG.Direction = "out";
ARG.IsReturnValue = true;
ARG.ParentAction = NewAction;
ARG.StateVarName = this.GetStateVariableObject(MethodName, retname).Name;
NewAction.AddArgument(ARG);
}
foreach (ParameterInfo p in pinfo)
{
ARG = new UPnPArgument(p.Name, "");
ARG.DataType = UPnPStateVariable.ConvertToUPnPType(p.ParameterType);
ARG.Direction = p.Attributes == ParameterAttributes.Out ? "out" : "in";
ARG.IsReturnValue = false;
ARG.ParentAction = NewAction;
ARG.StateVarName = this.GetStateVariableObject(MethodName, p.Name).Name;
NewAction.AddArgument(ARG);
}
this.AddAction(NewAction);
}
protected void LastChange_ModifiedSink(UPnPStateVariable Var, object NewValue)
{
if(OnStateVariable_LastChange != null) OnStateVariable_LastChange((System.String)NewValue);
WeakReference[] w = (WeakReference[])WeakList_LastChange.ToArray(typeof(WeakReference));
foreach(WeakReference wr in w)
{
if(wr.IsAlive==true)
{
((StateVariableModifiedHandler_LastChange)wr.Target)((System.String)NewValue);
}
else
{
WeakList_LastChange.Remove(wr);
}
}
}
/// <summary>
/// Add a UPnPStateVariable
/// </summary>
/// <param name="NewVar"></param>
public void AddStateVariable(UPnPStateVariable NewVar)
{
NewVar.ParentService = this;
StateVariables[NewVar.Name] = NewVar;
UPnPStateVariable.AssociationNode[] Nodes;
Hashtable ArgTable;
Nodes = NewVar.GetAssociations();
for (int x = 0; x < Nodes.Length; ++x)
{
ArgTable = (Hashtable)VarAssociation[Nodes[x].ActionName];
if (ArgTable == null) ArgTable = new Hashtable();
if (ArgTable.ContainsKey(Nodes[x].ArgName) == true)
{
StateVariables.Remove(((UPnPStateVariable)ArgTable[Nodes[x].ArgName]).Name);
}
ArgTable[Nodes[x].ArgName] = NewVar;
VarAssociation[Nodes[x].ActionName] = ArgTable;
// THIS: Updated to throw meaningfull exception instead of null reference
UPnPAction A = GetAction(Nodes[x].ActionName);
if (A != null)
{
UPnPArgument Argument = A.GetArg(Nodes[x].ArgName);
if (Argument == null)
{
throw (new Exception(string.Format("There is no parameter named {0} for the {1}.{2} method.", Nodes[x].ArgName, ServiceInstance.GetType().ToString(), Nodes[x].ActionName)));
}
Argument.StateVarName = NewVar.Name;
}
// THIS: End update
}
}
