internal static CpService ConnectService(DeviceConnection connection, CpDevice parentDevice, ServiceDescriptor serviceDescriptor, DataTypeResolverDlgt dataTypeResolver) { lock (connection.CPData.SyncObj) { CpService result = new CpService(connection, parentDevice, serviceDescriptor.ServiceType, serviceDescriptor.ServiceTypeVersion, serviceDescriptor.ServiceId); XPathNavigator serviceNav = serviceDescriptor.ServiceDescription.CreateNavigator(); serviceNav.MoveToChild(XPathNodeType.Element); XmlNamespaceManager nsmgr = new XmlNamespaceManager(serviceNav.NameTable); nsmgr.AddNamespace("s", UPnPConsts.NS_SERVICE_DESCRIPTION); XPathNodeIterator svIt = serviceNav.Select("s:serviceStateTable/s:stateVariable", nsmgr); // State variables must be connected first because they are needed from the action's arguments while (svIt.MoveNext()) { result.AddStateVariable(CpStateVariable.ConnectStateVariable(connection, result, svIt.Current, nsmgr, dataTypeResolver)); } XPathNodeIterator acIt = serviceNav.Select("s:actionList/s:action", nsmgr); while (acIt.MoveNext()) { result.AddAction(CpAction.ConnectAction(connection, result, acIt.Current, nsmgr)); } return(result); } }
internal static CpDevice ConnectDevice(DeviceConnection connection, DeviceDescriptor deviceDescriptor, DataTypeResolverDlgt dataTypeResolver) { lock (connection.CPData.SyncObj) { string type; int version; if (!deviceDescriptor.GetTypeAndVersion(out type, out version)) { throw new ArgumentException(string.Format("Invalid device type/version URN '{0}'", deviceDescriptor.TypeVersion_URN)); } CpDevice result = new CpDevice(connection, type, version, deviceDescriptor.DeviceUUID); foreach (DeviceDescriptor childDevice in deviceDescriptor.ChildDevices) { result.AddEmbeddedDevice(ConnectDevice(connection, childDevice, dataTypeResolver)); } IDictionary <string, ServiceDescriptor> serviceDescriptors; if (deviceDescriptor.RootDescriptor.ServiceDescriptors.TryGetValue(deviceDescriptor.DeviceUUID, out serviceDescriptors)) { foreach (ServiceDescriptor serviceDescriptor in serviceDescriptors.Values) { if (serviceDescriptor.State == ServiceDescriptorState.Ready) { result.AddService(CpService.ConnectService(connection, result, serviceDescriptor, dataTypeResolver)); } else { UPnPConfiguration.LOGGER.Warn("CpDevice.ConnectDevice: Unable to connect to service '{0}' (type '{1}', version '{2}') - the service descriptor was not initialized properly", serviceDescriptor.ServiceId, serviceDescriptor.ServiceType, serviceDescriptor.ServiceTypeVersion); } } } return(result); } }
/// <summary> /// Creates a new <see cref="CpStateVariable"/> instance. /// </summary> /// <param name="connection">Device connection instance which attends the connection with the server side.</param> /// <param name="parentService">Instance of the service which contains the new state variable.</param> /// <param name="name">Name of the state variable.</param> /// <param name="dataType">Data type of the state variable.</param> public CpStateVariable(DeviceConnection connection, CpService parentService, string name, CpDataType dataType) { _connection = connection; _parentService = parentService; _name = name; _dataType = dataType; }
public EventSubscription(string sid, ServiceDescriptor serviceDescriptor, CpService service, DateTime expiration) { _sid = sid; _serviceDescriptor = serviceDescriptor; _service = service; _expiration = expiration; }
internal static CpArgument CreateArgument(CpAction parentAction, CpService parentService, XPathNavigator argumentNav, IXmlNamespaceResolver nsmgr) { string name = ParserHelper.SelectText(argumentNav, "s:name/text()", nsmgr); string relatedStateVariableName = ParserHelper.SelectText(argumentNav, "s:relatedStateVariable/text()", nsmgr); CpStateVariable relatedStateVariable; if (!parentService.StateVariables.TryGetValue(relatedStateVariableName, out relatedStateVariable)) { throw new ArgumentException("Related state variable '{0}' is not present in service", relatedStateVariableName); } string direction = ParserHelper.SelectText(argumentNav, "s:direction/text()", nsmgr); XPathNodeIterator retValIt = argumentNav.Select("s:retval", nsmgr); CpArgument result = new CpArgument(parentAction, name, relatedStateVariable, ParseArgumentDirection(direction), retValIt.MoveNext()); return(result); }
internal static CpAction ConnectAction(DeviceConnection connection, CpService parentService, XPathNavigator actionNav, IXmlNamespaceResolver nsmgr) { using (connection.CPData.Lock.EnterWrite()) { string name = ParserHelper.SelectText(actionNav, "s:name/text()", nsmgr); CpAction result = new CpAction(connection, parentService, name); XPathNodeIterator argumentIt = actionNav.Select("s:argumentList/s:argument", nsmgr); while (argumentIt.MoveNext()) { CpArgument argument = CpArgument.CreateArgument(result, parentService, argumentIt.Current, nsmgr); if (argument.Direction == ArgumentDirection.In) { result.AddInAgrument(argument); } else { result.AddOutAgrument(argument); } } return(result); } }
/// <summary> /// Adds the specified <paramref name="service"/>. /// </summary> /// <param name="service">Service to add to this device.</param> internal void AddService(CpService service) { _services.Add(service.ServiceId, service); }
public NativeTvProxy(CpService serviceStub) : base(serviceStub, "NativeTv") { ServiceRegistration.Set<ITvProvider>(this); }
protected UPnPServiceProxyBase(CpService serviceStub, string serviceName) { _serviceName = serviceName; _serviceStub = serviceStub; _serviceStub.SubscribeStateVariables(); }
/// <summary> /// Returns the information whether the specified <paramref name="service"/> is registered for event notifications. /// </summary> /// <remarks> /// When subscribing for state variable changes of a given service s, this method doesn't return <c>true</c> when invoked /// for that service s immediately. The subscription must first be confirmed by the UPnP network service. /// </remarks> /// <param name="service">The service instance to check.</param> /// <returns><c>true</c>, if the <paramref name="service"/> is subscribed for receiving event notifications, else /// <c>false</c>.</returns> public bool IsServiceSubscribedForEvents(CpService service) { lock (_cpData.SyncObj) return _genaClientController.FindEventSubscriptionByService(service) != null; }
internal void OnUnsubscribeEvents(CpService service) { if (!service.IsConnected) throw new IllegalCallException("Service '{0}' is not connected to a UPnP network service", service.FullQualifiedName); EventSubscription subscription = _genaClientController.FindEventSubscriptionByService(service); if (subscription == null) throw new IllegalCallException("Service '{0}' is not subscribed to receive events", service.FullQualifiedName); _genaClientController.UnsubscribeEvents(subscription); }
public ChangeEventSubscriptionState(ServiceDescriptor serviceDescriptor, CpService service, HttpWebRequest request) : base(request) { _serviceDescriptor = serviceDescriptor; _service = service; }
public UPnPUserProfileDataManagementServiceProxy(CpService serviceStub) : base(serviceStub, "UserProfileDataManagement") { }
public UPnPContentDirectoryServiceProxy(CpService serviceStub) : base(serviceStub, "ContentDirectory") { serviceStub.StateVariableChanged += OnStateVariableChanged; serviceStub.SubscribeStateVariables(); }
internal static CpStateVariable ConnectStateVariable(DeviceConnection connection, CpService parentService, XPathNavigator svIt, IXmlNamespaceResolver nsmgr, DataTypeResolverDlgt dataTypeResolver) { string name = ParserHelper.SelectText(svIt, "s:name/text()", nsmgr); XPathNodeIterator dtIt = svIt.Select("s:dataType", nsmgr); if (!dtIt.MoveNext()) throw new ArgumentException("Error evaluating data type element"); CpDataType dataType = CpDataType.CreateDataType(dtIt.Current, nsmgr, dataTypeResolver); CpStateVariable result = new CpStateVariable(connection, parentService, name, dataType); XPathNodeIterator dvIt = svIt.Select("s:defaultValue", nsmgr); if (dvIt.MoveNext()) { XmlReader reader = dvIt.Current.ReadSubtree(); reader.MoveToContent(); result.DefaultValue = dataType.SoapDeserializeValue(reader, true); // Default value is always simple value (see DevArch) } XPathNodeIterator avlIt = svIt.Select("s:allowedValueList/s:allowedValue", nsmgr); if (avlIt.Count > 0) { IList<string> allowedValueList = new List<string>(); while (avlIt.MoveNext()) allowedValueList.Add(ParserHelper.SelectText(avlIt.Current, "text()", null)); result.AllowedValueList = allowedValueList; } XPathNodeIterator avrIt = svIt.Select("s:allowedValueRange", nsmgr); if (avrIt.MoveNext()) result.AllowedValueRange = CpAllowedValueRange.CreateAllowedValueRange(avrIt.Current, nsmgr); return result; }
public UPnPServerControllerServiceProxy(CpService serviceStub) : base(serviceStub, "ServerController") { serviceStub.StateVariableChanged += OnStateVariableChanged; serviceStub.SubscribeStateVariables(); }
protected static void HandleVariableChangeNotification(XmlReader reader, CpService service, UPnPVersion upnpVersion) { string variableName = reader.LocalName; CpStateVariable stateVariable; if (!service.StateVariables.TryGetValue(variableName, out stateVariable)) // We don't know that variable - this is an error case but we won't raise an exception here return; object value = stateVariable.DataType.SoapDeserializeValue(reader, upnpVersion.VerMin == 0); service.InvokeStateVariableChanged(stateVariable, value); }
/// <summary> /// Creates a new instance of <see cref="CpAction"/>. /// </summary> /// <param name="connection">Device connection instance which attends the connection with the server side.</param> /// <param name="parentService">Instance of the service which contains the new action.</param> /// <param name="name">The name of the new action template.</param> public CpAction(DeviceConnection connection, CpService parentService, string name) { _connection = connection; _parentService = parentService; _name = name; }
internal void OnSubscribeEvents(CpService service) { if (!service.IsConnected) throw new IllegalCallException("Service '{0}' is not connected to a UPnP network service", service.FullQualifiedName); if (IsServiceSubscribedForEvents(service)) throw new IllegalCallException("Service '{0}' is already subscribed to receive state variable change events", service.FullQualifiedName); ServiceDescriptor serviceDescriptor = GetServiceDescriptor(service); _genaClientController.SubscribeEvents(service, serviceDescriptor); }
internal static CpAction ConnectAction(DeviceConnection connection, CpService parentService, XPathNavigator actionNav, IXmlNamespaceResolver nsmgr) { lock (connection.CPData.SyncObj) { string name = ParserHelper.SelectText(actionNav, "s:name/text()", nsmgr); CpAction result = new CpAction(connection, parentService, name); XPathNodeIterator argumentIt = actionNav.Select("s:argumentList/s:argument", nsmgr); while (argumentIt.MoveNext()) { CpArgument argument = CpArgument.CreateArgument(result, parentService, argumentIt.Current, nsmgr); if (argument.Direction == ArgumentDirection.In) result.AddInAgrument(argument); else result.AddOutAgrument(argument); } return result; } }
protected ServiceDescriptor GetServiceDescriptor(CpService service) { if (!service.IsConnected) throw new IllegalCallException("Service '{0}' is not connected to a UPnP network service", service.FullQualifiedName); IDictionary<string, ServiceDescriptor> serviceDescriptors; string deviceUUID = service.ParentDevice.UUID; if (!_rootDescriptor.ServiceDescriptors.TryGetValue(deviceUUID, out serviceDescriptors)) throw new IllegalCallException("Device '{0}' is not connected to a UPnP network device", deviceUUID); ServiceDescriptor sd; if (!serviceDescriptors.TryGetValue(service.ServiceTypeVersion_URN, out sd)) throw new IllegalCallException("Service '{0}' in device '{1}' is not connected to a UPnP network service", service.ServiceTypeVersion_URN, deviceUUID); return sd; }
public UPnPClientControllerServiceProxy(CpService serviceStub) : base(serviceStub, "ClientController") { }
internal static CpArgument CreateArgument(CpAction parentAction, CpService parentService, XPathNavigator argumentNav, IXmlNamespaceResolver nsmgr) { string name = ParserHelper.SelectText(argumentNav, "s:name/text()", nsmgr); string relatedStateVariableName = ParserHelper.SelectText(argumentNav, "s:relatedStateVariable/text()", nsmgr); CpStateVariable relatedStateVariable; if (!parentService.StateVariables.TryGetValue(relatedStateVariableName, out relatedStateVariable)) throw new ArgumentException("Related state variable '{0}' is not present in service", relatedStateVariableName); string direction = ParserHelper.SelectText(argumentNav, "s:direction/text()", nsmgr); XPathNodeIterator retValIt = argumentNav.Select("s:retval", nsmgr); CpArgument result = new CpArgument(parentAction, name, relatedStateVariable, ParseArgumentDirection(direction), retValIt.MoveNext()); return result; }
internal static CpService ConnectService(DeviceConnection connection, CpDevice parentDevice, ServiceDescriptor serviceDescriptor, DataTypeResolverDlgt dataTypeResolver) { lock (connection.CPData.SyncObj) { CpService result = new CpService(connection, parentDevice, serviceDescriptor.ServiceType, serviceDescriptor.ServiceTypeVersion, serviceDescriptor.ServiceId); XPathNavigator serviceNav = serviceDescriptor.ServiceDescription.CreateNavigator(); serviceNav.MoveToChild(XPathNodeType.Element); XmlNamespaceManager nsmgr = new XmlNamespaceManager(serviceNav.NameTable); nsmgr.AddNamespace("s", UPnPConsts.NS_SERVICE_DESCRIPTION); XPathNodeIterator svIt = serviceNav.Select("s:serviceStateTable/s:stateVariable", nsmgr); // State variables must be connected first because they are needed from the action's arguments while (svIt.MoveNext()) result.AddStateVariable(CpStateVariable.ConnectStateVariable(connection, result, svIt.Current, nsmgr, dataTypeResolver)); XPathNodeIterator acIt = serviceNav.Select("s:actionList/s:action", nsmgr); while (acIt.MoveNext()) result.AddAction(CpAction.ConnectAction(connection, result, acIt.Current, nsmgr)); return result; } }
public FanArtServiceProxy(CpService serviceStub) : base(serviceStub, "FanArt") { ServiceRegistration.Set<IFanArtService>(this); }
internal static CpStateVariable ConnectStateVariable(DeviceConnection connection, CpService parentService, XPathNavigator svIt, IXmlNamespaceResolver nsmgr, DataTypeResolverDlgt dataTypeResolver) { string name = ParserHelper.SelectText(svIt, "s:name/text()", nsmgr); XPathNodeIterator dtIt = svIt.Select("s:dataType", nsmgr); if (!dtIt.MoveNext()) { throw new ArgumentException("Error evaluating data type element"); } CpDataType dataType = CpDataType.CreateDataType(dtIt.Current, nsmgr, dataTypeResolver); CpStateVariable result = new CpStateVariable(connection, parentService, name, dataType); XPathNodeIterator dvIt = svIt.Select("s:defaultValue", nsmgr); if (dvIt.MoveNext()) { XmlReader reader = dvIt.Current.ReadSubtree(); reader.MoveToContent(); result.DefaultValue = dataType.SoapDeserializeValue(reader, true); // Default value is always simple value (see DevArch) } XPathNodeIterator avlIt = svIt.Select("s:allowedValueList/s:allowedValue", nsmgr); if (avlIt.Count > 0) { IList <string> allowedValueList = new List <string>(); while (avlIt.MoveNext()) { allowedValueList.Add(ParserHelper.SelectText(avlIt.Current, "text()", null)); } result.AllowedValueList = allowedValueList; } XPathNodeIterator avrIt = svIt.Select("s:allowedValueRange", nsmgr); if (avrIt.MoveNext()) { result.AllowedValueRange = CpAllowedValueRange.CreateAllowedValueRange(avrIt.Current, nsmgr); } return(result); }
internal void SubscribeEvents(CpService service, ServiceDescriptor serviceDescriptor) { lock (_cpData.SyncObj) { HttpWebRequest request = CreateEventSubscribeRequest(serviceDescriptor); ChangeEventSubscriptionState state = new ChangeEventSubscriptionState(serviceDescriptor, service, request); _pendingCalls.Add(state); IAsyncResult result = state.Request.BeginGetResponse(OnSubscribeOrRenewSubscriptionResponseReceived, state); NetworkHelper.AddTimeout(request, result, EVENT_SUBSCRIPTION_CALL_TIMEOUT * 1000); } }
public UPnPResourceInformationServiceProxy(CpService serviceStub) : base(serviceStub, "ResourceInformation") { }
public EventSubscription FindEventSubscriptionByService(CpService service) { lock (_cpData.SyncObj) foreach (EventSubscription subscription in _subscriptions.Values) if (subscription.Service == service) return subscription; return null; }
protected bool TryGetService(string usn, string svcid, out CpService service) { string deviceUUID; string serviceTypeVersion; service = null; if (!ParserHelper.TryParseUSN(usn, out deviceUUID, out serviceTypeVersion)) return false; string type; int version; if (!ParserHelper.TryParseTypeVersion_URN(serviceTypeVersion, out type, out version)) return false; foreach (CpService matchingService in _connection.Device.FindServicesByServiceTypeAndVersion(type, version, false)) { if (matchingService.ServiceId == svcid) { service = matchingService; return true; } } return false; }
public static HttpStatusCode HandleEventNotification(Stream stream, Encoding streamEncoding, CpService service, UPnPVersion upnpVersion) { try { // Parse XML document using (StreamReader streamReader = new StreamReader(stream, streamEncoding)) using (XmlReader reader = XmlReader.Create(streamReader, UPnPConfiguration.DEFAULT_XML_READER_SETTINGS)) { reader.MoveToContent(); reader.ReadStartElement("propertyset", UPnPConsts.NS_UPNP_EVENT); while (reader.LocalName == "property" && reader.NamespaceURI == UPnPConsts.NS_UPNP_EVENT) { reader.ReadStartElement("property", UPnPConsts.NS_UPNP_EVENT); HandleVariableChangeNotification(reader, service, upnpVersion); reader.ReadEndElement(); // property } reader.Close(); } return HttpStatusCode.OK; } catch (Exception e) { UPnPConfiguration.LOGGER.Warn("GENAClientController: Error handling event notification", e); return HttpStatusCode.BadRequest; } }
private void SubscribeFailed(CpService service, UPnPError error) { Log.Log.Error("DRI: failed to subscribe to state variable events for service {0}, code = {1}, description = {2}", _unqualifiedServiceName, error.ErrorCode, error.ErrorDescription); }