protected DeviceConnection DoConnect(RootDescriptor descriptor, string deviceUuid, DataTypeResolverDlgt dataTypeResolver, bool useHttpKeepAlive = true) { lock (_cpData.SyncObj) { DeviceConnection connection = new DeviceConnection(this, descriptor, deviceUuid, _cpData, dataTypeResolver, useHttpKeepAlive); _connectedDevices.Add(deviceUuid, connection); return(connection); } }
public ServerSettingsProxy RegisterServerSettingsProxy(DeviceConnection connection) { CpService serverSettingsStub = connection.Device.FindServiceByServiceId(Consts.SERVERSETTINGS_SERVICE_ID); if (serverSettingsStub == null) throw new NotSupportedException("ServerSettingsProxy not supported by this UPnP device."); ServerSettingsProxy settingsProxy = new ServerSettingsProxy(serverSettingsStub); return settingsProxy; }
public static FanArtServiceProxy RegisterFanArtServiceProxy(DeviceConnection connection) { CpService fanArtStub = connection.Device.FindServiceByServiceId(Consts.FANART_SERVICE_ID); if (fanArtStub == null) throw new NotSupportedException("FanArtService not supported by this UPnP device."); FanArtServiceProxy fanArtProxy = new FanArtServiceProxy(fanArtStub); return fanArtProxy; }
protected void DoDisconnect(DeviceConnection connection, bool unsubscribeEvents) { lock (_cpData.SyncObj) { string deviceUUID = connection.DeviceUUID; if (!_connectedDevices.ContainsKey(deviceUUID)) { throw new ArgumentException(string.Format("This control point instance doesn't manage the given device connection for device '{0}'", connection.DeviceUUID)); } DoDisconnect(deviceUUID, unsubscribeEvents); } }
private void OnBackendServerConnected(DeviceConnection connection) { ServerDescriptor serverDescriptor = ServerDescriptor.GetMPBackendServerDescriptor(connection.RootDescriptor); if (serverDescriptor == null) { ServiceRegistration.Get<ILogger>().Warn("ServerConnectionManager: Could not connect to home server - Unable to verify UPnP root descriptor"); return; } SystemName preferredLink = serverDescriptor.GetPreferredLink(); ServiceRegistration.Get<ILogger>().Info("ServerConnectionManager: Connected to home server '{0}' at host '{1}' (IP address: '{2}')", serverDescriptor.MPBackendServerUUID, preferredLink.HostName, preferredLink.Address); lock (_syncObj) { _isHomeServerConnected = true; SaveLastHomeServerData(serverDescriptor); } ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerConnected); ServiceRegistration.Get<IThreadPool>().Add(CompleteServerConnection); }
public ClientConnection(UPnPControlPoint controlPoint, DeviceConnection connection, ClientDescriptor clientDescriptor) { _controlPoint = controlPoint; _connection = connection; _clientDescriptor = clientDescriptor; _connection.DeviceDisconnected += OnUPnPDeviceDisconnected; try { CpService ccsStub = connection.Device.FindServiceByServiceId(UPnPTypesAndIds.CLIENT_CONTROLLER_SERVICE_ID); if (ccsStub == null) throw new InvalidDataException("ClientController service not found in device '{0}' of type '{1}:{2}'", clientDescriptor.MPFrontendServerUUID, UPnPTypesAndIds.FRONTEND_SERVER_DEVICE_TYPE, UPnPTypesAndIds.FRONTEND_SERVER_DEVICE_TYPE_VERSION); lock (_connection.CPData.SyncObj) _clientController = new UPnPClientControllerServiceProxy(ccsStub); // TODO: other services } catch (Exception) { _connection.DeviceDisconnected -= OnUPnPDeviceDisconnected; throw; } }
void OnUPnPDeviceDisconnected(DeviceConnection connection) { _clientController = null; InvokeClientDeviceDisconnected(this); }
/// <summary> /// Disconnects the connected device specified by the given <paramref name="connection"/> instance. /// </summary> /// <param name="connection">Connection instance to disconnect. Must be maintained by this instance, i.e. must have been /// returned by method <see cref="Connect"/> of this instance.</param> public void Disconnect(DeviceConnection connection) { DoDisconnect(connection, true); }
public NativeTvProxy RegisterNativeTvProxy(DeviceConnection connection) { CpService tvStub = connection.Device.FindServiceByServiceId(Consts.SLIMTV_SERVICE_ID); if (tvStub == null) throw new NotSupportedException("NativeTvService not supported by this UPnP device."); NativeTvProxy tvProxy = new NativeTvProxy(tvStub); return tvProxy; }
/// <summary> /// Build the graph. /// </summary> public override void BuildGraph() { try { if (_graphState != GraphState.Idle) { Log.Log.Info("DRI CC: device already initialised"); return; } bool useKeepAlive = !_isCetonDevice; Log.Log.Info("DRI CC: connect to device, keep-alive = {0}", useKeepAlive); _deviceConnection = _controlPoint.Connect(_descriptor.RootDescriptor, _descriptor.DeviceUUID, ResolveDataType, useKeepAlive); // services Log.Log.Debug("DRI CC: setup services"); _tunerService = new TunerService(_deviceConnection.Device); _fdcService = new FdcService(_deviceConnection.Device); _auxService = new AuxService(_deviceConnection.Device); _encoderService = new EncoderService(_deviceConnection.Device); _casService = new CasService(_deviceConnection.Device); _muxService = new MuxService(_deviceConnection.Device); _securityService = new SecurityService(_deviceConnection.Device); _diagService = new DiagService(_deviceConnection.Device); _avTransportService = new AvTransportService(_deviceConnection.Device); _connectionManagerService = new ConnectionManagerService(_deviceConnection.Device); Log.Log.Debug("DRI CC: subscribe services"); _stateVariableDelegate = new StateVariableChangedDlgt(OnStateVariableChanged); _tunerService.SubscribeStateVariables(_stateVariableDelegate); _auxService.SubscribeStateVariables(_stateVariableDelegate); _encoderService.SubscribeStateVariables(_stateVariableDelegate); _casService.SubscribeStateVariables(_stateVariableDelegate); _securityService.SubscribeStateVariables(_stateVariableDelegate); _avTransportService.SubscribeStateVariables(_stateVariableDelegate); _connectionManagerService.SubscribeStateVariables(_stateVariableDelegate); // Give time for the device to notify us about initial state variable values. // Attempting to continue with other actions now can overload the puny device // processors. Thread.Sleep(2000); int rcsId = -1; _connectionManagerService.PrepareForConnection(string.Empty, string.Empty, -1, UpnpConnectionDirection.Output, out _connectionId, out _avTransportId, out rcsId); Log.Log.Debug("DRI CC: PrepareForConnection, connection ID = {0}, AV transport ID = {1}", _connectionId, _avTransportId); // Check that the device is not already in use. if (IsTunerInUse()) { throw new TvExceptionGraphBuildingFailed("DRI CC: tuner appears to be in use"); } ReadDeviceInfo(); Log.Log.Info("DRI CC: build graph"); _graphBuilder = (IFilterGraph2)new FilterGraph(); _capBuilder = (ICaptureGraphBuilder2)new CaptureGraphBuilder2(); _capBuilder.SetFiltergraph(_graphBuilder); _rotEntry = new DsROTEntry(_graphBuilder); AddTsWriterFilterToGraph(); AddStreamSourceFilter(); // This shouldn't be required, but it enables us to reuse TvCardDvbBase // and use CI menus for delivering messages from the CableCARD to the // user. _conditionalAccess = new ConditionalAccess(null, null, null, this); _graphState = GraphState.Created; } catch (Exception) { Dispose(); throw; } }
void OnUPnPDeviceDisconnected(DeviceConnection connection) { IEnumerable<UPnPServiceProxyBase> servicesToDispose; lock (_networkTracker.SharedControlPointData.SyncObj) { _connection = null; _contentDirectoryService = null; _resourceInformationService = null; _serverControllerService = null; servicesToDispose = _additionalServices; _additionalServices.Clear(); } // Dispose all additional services if possible, to allow proper shutdown and cleanup foreach (UPnPServiceProxyBase service in servicesToDispose) { IDisposable disposable = service as IDisposable; if (disposable == null) continue; try { disposable.Dispose(); } catch (Exception e) { ServiceRegistration.Get<ILogger>().Warn("UPnPClientControlPoint: Error disposing additional service '{0}'", service, e); } } InvokeBackendServerDeviceDisconnected(connection); }
protected void InvokeBackendServerDeviceDisconnected(DeviceConnection connection) { BackendServerDisconnectedDlgt dlgt = BackendServerDisconnected; if (dlgt != null) dlgt(connection); }
protected void DoDisconnect(DeviceConnection connection, bool unsubscribeEvents) { lock (_cpData.SyncObj) { string deviceUUID = connection.DeviceUUID; if (!_connectedDevices.ContainsKey(deviceUUID)) throw new ArgumentException(string.Format("This control point instance doesn't manage the given device connection for device '{0}'", connection.DeviceUUID)); DoDisconnect(deviceUUID, unsubscribeEvents); } }
protected void TryConnect(RootDescriptor rootDescriptor) { DeviceConnection connection; string deviceUuid; lock (_networkTracker.SharedControlPointData.SyncObj) { if (_connection != null) return; DeviceDescriptor rootDeviceDescriptor = DeviceDescriptor.CreateRootDeviceDescriptor(rootDescriptor); DeviceDescriptor backendServerDescriptor = rootDeviceDescriptor.FindFirstDevice( UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE_VERSION); if (backendServerDescriptor == null) return; deviceUuid = backendServerDescriptor.DeviceUUID; string friendlyName = backendServerDescriptor.FriendlyName; SystemName system = new SystemName(new Uri(rootDescriptor.SSDPRootEntry.PreferredLink.DescriptionLocation).Host); if (deviceUuid == _homeServerSystemId) ServiceRegistration.Get<ILogger>().Debug("UPnPClientControlPoint: Found MP2 home server '{0}' (system ID '{1}') at host '{2}' (IP address: '{3}')", friendlyName, deviceUuid, system.HostName, system.Address); else { ServiceRegistration.Get<ILogger>().Debug("UPnPClientControlPoint: Found foreign MP2 server '{0}' (system ID '{1}') at host '{2}' (IP address: '{3}')", friendlyName, deviceUuid, system.HostName, system.Address); return; } try { connection = _connection = _controlPoint.Connect(rootDescriptor, deviceUuid, UPnPExtendedDataTypes.ResolveDataType); } catch (Exception e) { ServiceRegistration.Get<ILogger>().Warn("UPnPClientControlPoint: Error connecting to UPnP MP2 backend server '{0}'", e, deviceUuid); return; } } connection.DeviceDisconnected += OnUPnPDeviceDisconnected; try { CpService cdsStub = connection.Device.FindServiceByServiceId(UPnPTypesAndIds.CONTENT_DIRECTORY_SERVICE_ID); if (cdsStub == null) throw new InvalidDataException("ContentDirectory service not found in device '{0}' of type '{1}:{2}'", deviceUuid, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE_VERSION); CpService risStub = connection.Device.FindServiceByServiceId(UPnPTypesAndIds.RESOURCE_INFORMATION_SERVICE_ID); if (risStub == null) throw new InvalidDataException("ResourceAccess service not found in device '{0}' of type '{1}:{2}'", deviceUuid, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE_VERSION); CpService scsStub = connection.Device.FindServiceByServiceId(UPnPTypesAndIds.SERVER_CONTROLLER_SERVICE_ID); if (scsStub == null) throw new InvalidDataException("ServerController service not found in device '{0}' of type '{1}:{2}'", deviceUuid, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE_VERSION); CpService updmStub = connection.Device.FindServiceByServiceId(UPnPTypesAndIds.USER_PROFILE_DATA_MANAGEMENT_SERVICE_ID); if (updmStub == null) throw new InvalidDataException("UserProfileDataManagement service not found in device '{0}' of type '{1}:{2}'", deviceUuid, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE, UPnPTypesAndIds.BACKEND_SERVER_DEVICE_TYPE_VERSION); lock (_networkTracker.SharedControlPointData.SyncObj) { _contentDirectoryService = new UPnPContentDirectoryServiceProxy(cdsStub); _resourceInformationService = new UPnPResourceInformationServiceProxy(risStub); _serverControllerService = new UPnPServerControllerServiceProxy(scsStub); _userProfileDataManagementService = new UPnPUserProfileDataManagementServiceProxy(updmStub); } ICollection<UPnPServiceProxyBase> additionalServices = new List<UPnPServiceProxyBase>(); foreach (AdditionalServiceRegisterDlgt additionalServiceRegistration in _additionalServiceRegistrations) { try { additionalServices.Add(additionalServiceRegistration(connection)); } catch (Exception e) { ServiceRegistration.Get<ILogger>().Warn("UPnPClientControlPoint: Error registering user service for UPnP MP2 backend server '{0}'", e, deviceUuid); } } lock (_networkTracker.SharedControlPointData.SyncObj) _additionalServices = additionalServices; } catch (Exception e) { ServiceRegistration.Get<ILogger>().Warn("UPnPClientControlPoint: Error connecting to services of UPnP MP2 backend server '{0}'", e, deviceUuid); connection.DeviceDisconnected -= OnUPnPDeviceDisconnected; _controlPoint.Disconnect(deviceUuid); return; } InvokeBackendServerDeviceConnected(connection); }
protected DeviceConnection DoConnect(RootDescriptor descriptor, string deviceUuid, DataTypeResolverDlgt dataTypeResolver, bool useHttpKeepAlive = true) { lock (_cpData.SyncObj) { DeviceConnection connection = new DeviceConnection(this, descriptor, deviceUuid, _cpData, dataTypeResolver, useHttpKeepAlive); _connectedDevices.Add(deviceUuid, connection); return connection; } }
public override void Dispose() { if (_eventSignalLock != null) { _eventSignalLock.Close(); _eventSignalLock = null; } base.Dispose(); RemoveStreamSourceFilter(); if (_mpeg2TransportStream != null) { DsUtils.FreeAMMediaType(_mpeg2TransportStream); _mpeg2TransportStream = null; } if (_tunerService != null) { _tunerService.Dispose(); _tunerService = null; } if (_fdcService != null) { _fdcService.Dispose(); _fdcService = null; } if (_auxService != null) { _auxService.Dispose(); _auxService = null; } if (_encoderService != null) { _encoderService.Dispose(); _encoderService = null; } if (_casService != null) { _casService.Dispose(); _casService = null; } if (_muxService != null) { _muxService.Dispose(); _muxService = null; } if (_securityService != null) { _securityService.Dispose(); _securityService = null; } if (_diagService != null) { _diagService.Dispose(); _diagService = null; } if (_avTransportService != null) { if (_gotTunerControl && _transportState != UpnpAvTransportState.STOPPED) { _avTransportService.Stop((uint)_avTransportId); _transportState = UpnpAvTransportState.STOPPED; } _avTransportService.Dispose(); _avTransportService = null; } if (_connectionManagerService != null) { _connectionManagerService.ConnectionComplete(_connectionId); _connectionManagerService.Dispose(); _connectionManagerService = null; } if (_deviceConnection != null) { _deviceConnection.Disconnect(); _deviceConnection = null; } _gotTunerControl = false; }
private void OnBackendServerDisconnected(DeviceConnection connection) { lock (_syncObj) _isHomeServerConnected = false; ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerDisconnected); }
void OnBackendServerDisconnected(DeviceConnection connection) { lock (_syncObj) _isHomeServerConnected = false; IImporterWorker importerWorker = ServiceRegistration.Get<IImporterWorker>(); importerWorker.Suspend(); UpdateCurrentlyImportingShares(null); // Mark all shares as not being imported ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerDisconnected); }