private void AddDevice(DiscoveredSsdpDevice device, SsdpDevice fullDevice) { var existingDevice = deviceList.FirstOrDefault(d => d.GetHost().Equals(device.DescriptionLocation.Host)); if (existingDevice == null) { if (!deviceList.Any(d => d.GetUsn().Equals(device.Usn))) { var newDevice = DependencyFactory.Container.Resolve <Device>(); newDevice.SetDiscoveredDevices(device, fullDevice); deviceList.Add(newDevice); onAddDeviceCallback?.Invoke(newDevice); if (AutoStart) { newDevice.OnClickDeviceButton(null, null); } } } else { existingDevice.SetDiscoveredDevices(device, fullDevice); existingDevice.GetDeviceControl()?.SetDeviceName(existingDevice.GetFriendlyName()); existingDevice.GetMenuItem().Text = existingDevice.GetFriendlyName(); } }
public void DeviceLocator_Notifications_ReceivesByeByeNotificationsForKnownDevice() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); var receivedNotification = false; DiscoveredSsdpDevice device = null; bool expired = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceUnavailable += (sender, args) => { device = args.DiscoveredDevice; expired = args.Expired; receivedNotification = true; eventSignal.Set(); }; deviceLocator.StartListeningForNotifications(); server.MockReceiveBroadcast(GetMockAliveNotification()); server.WaitForMessageToProcess(10000); server.MockReceiveBroadcast(GetMockByeByeNotification()); eventSignal.WaitOne(10000); } Assert.IsTrue(receivedNotification); Assert.IsNotNull(device); Assert.IsFalse(expired); }
private void ProcessByeByeNotification(HttpRequestMessage message) { var notficationType = GetFirstHeaderStringValue("NT", message); if (!String.IsNullOrEmpty(notficationType)) { var usn = GetFirstHeaderStringValue("USN", message); if (!DeviceDied(usn, false)) { var deadDevice = new DiscoveredSsdpDevice() { AsAt = DateTime.UtcNow, CacheLifetime = TimeSpan.Zero, DescriptionLocation = null, NotificationType = GetFirstHeaderStringValue("NT", message), Usn = usn }; if (NotificationTypeMatchesFilter(deadDevice)) { OnDeviceUnavailable(deadDevice, false); } } ResetExpireCachedDevicesTimer(); } }
public void DeviceLocator_Notifications_SearchResponseDefaultsToZeroMaxAge() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); var publishedDevice = CreateDeviceTree(); publishedDevice.CacheLifetime = TimeSpan.FromMinutes(30); DiscoveredSsdpDevice device = null; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceAvailable += (sender, args) => { device = args.DiscoveredDevice; eventSignal.Set(); }; var t = deviceLocator.SearchAsync(TimeSpan.FromSeconds(3)); System.Threading.Thread.Sleep(500); server.MockReceiveMessage(GetMockSearchResponseWithCustomCacheHeader(publishedDevice, publishedDevice.Udn, String.Format("CACHE-CONTROL: public"))); eventSignal.WaitOne(10000); var results = t.GetAwaiter().GetResult(); Assert.IsNotNull(results); Assert.IsTrue(results.Any()); Assert.AreEqual(TimeSpan.Zero, results.First().CacheLifetime); } }
public void DeviceLocator_SearchAsync_RaisesDeviceAvailableOnResponse() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); var publishedDevice = CreateDeviceTree(); DiscoveredSsdpDevice device = null; bool newlyDiscovered = false; var receivedNotification = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceAvailable += (sender, args) => { device = args.DiscoveredDevice; newlyDiscovered = args.IsNewlyDiscovered; receivedNotification = true; eventSignal.Set(); }; var task = deviceLocator.SearchAsync(TimeSpan.FromSeconds(2)); server.MockReceiveMessage(GetMockSearchResponse(publishedDevice, publishedDevice.Udn)); eventSignal.WaitOne(10000); Assert.IsTrue(receivedNotification); var results = task.GetAwaiter().GetResult(); Assert.IsNotNull(results); Assert.IsTrue(results.Any()); Assert.IsTrue(results.First().Usn == device.Usn); } }
public void DeviceLocator_Notifications_HandlesByeByeDuringSearch() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); DiscoveredSsdpDevice device = null; var receivedNotification = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceUnavailable += (sender, args) => { device = args.DiscoveredDevice; receivedNotification = true; eventSignal.Set(); }; deviceLocator.StartListeningForNotifications(); server.MockReceiveBroadcast(GetMockAliveNotification()); server.WaitForMessageToProcess(10000); var t = deviceLocator.SearchAsync(TimeSpan.FromSeconds(3)); System.Threading.Thread.Sleep(500); server.MockReceiveBroadcast(GetMockByeByeNotification()); eventSignal.WaitOne(10000); var results = t.GetAwaiter().GetResult(); Assert.IsNotNull(results); Assert.IsFalse(results.Any()); } Assert.IsTrue(receivedNotification); Assert.IsNotNull(device); }
public void DeviceLocator_Notifications_SearchResponseMissingCacheHeaderIsNonCacheable() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); var publishedDevice = CreateDeviceTree(); DiscoveredSsdpDevice device = null; var receivedNotification = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceAvailable += (sender, args) => { device = args.DiscoveredDevice; receivedNotification = true; eventSignal.Set(); }; var t = deviceLocator.SearchAsync(TimeSpan.FromSeconds(3)); System.Threading.Thread.Sleep(500); server.MockReceiveMessage(GetMockSearchResponseWithCustomCacheHeader(publishedDevice, publishedDevice.Udn, null)); eventSignal.WaitOne(10000); var results = t.GetAwaiter().GetResult(); Assert.IsNotNull(results); Assert.IsTrue(results.Any()); Assert.IsTrue(receivedNotification); Assert.IsNotNull(device); Assert.AreEqual(device.Usn, String.Format("{0}:{1}", publishedDevice.Udn, publishedDevice.FullDeviceType)); Assert.AreEqual(device.NotificationType, publishedDevice.Udn); } }
public void DeviceLocator_Notifications_DoesNotRaiseDeviceAvailableIfDisposed() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); DiscoveredSsdpDevice device = null; bool newlyDiscovered = false; var receivedNotification = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceAvailable += (sender, args) => { device = args.DiscoveredDevice; newlyDiscovered = args.IsNewlyDiscovered; receivedNotification = true; }; deviceLocator.StartListeningForNotifications(); server.MockReceiveBroadcast(GetMockAliveNotification()); server.Dispose(); eventSignal.WaitOne(1000); } Assert.IsFalse(receivedNotification); }
public void DeviceLocator_SearchAsync_ReturnsCachedDevices() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); DiscoveredSsdpDevice device = null; bool newlyDiscovered = false; var receivedNotification = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceAvailable += (sender, args) => { device = args.DiscoveredDevice; newlyDiscovered = args.IsNewlyDiscovered; receivedNotification = true; eventSignal.Set(); }; deviceLocator.StartListeningForNotifications(); server.MockReceiveBroadcast(GetMockAliveNotification()); eventSignal.WaitOne(10000); Assert.IsTrue(receivedNotification); var results = deviceLocator.SearchAsync(TimeSpan.Zero).GetAwaiter().GetResult(); Assert.IsNotNull(results); Assert.IsTrue(results.Any()); Assert.IsTrue(results.First().Usn == device.Usn); } }
public void TestDevices() { asyncEvent = new AutoResetEvent(false); // Add a device var devices = new Devices(); devices.SetCallback(OnAddDeviceCallback); var discoveredSsdpDevice = new DiscoveredSsdpDevice { Usn = "usn", DescriptionLocation = new System.Uri("http://192.168.111.111") }; var ssdpDevice = new SsdpRootDevice { FriendlyName = "Device_Name" }; devices.OnDeviceAvailable(discoveredSsdpDevice, ssdpDevice); asyncEvent.WaitOne(100); Assert.AreEqual(ssdpDevice.FriendlyName, device.GetFriendlyName()); Assert.AreEqual(discoveredSsdpDevice.Usn, device.GetUsn()); Assert.AreEqual(discoveredSsdpDevice.DescriptionLocation.Host, device.GetHost()); // Not connected, volume messages are not send. TestMessagesWhenNotConnected(devices); // Connect and launch app TestConnectAndLoadMedia(devices); // Test the other messages TestMessages(devices); }
public void DiscoveredDevice_GetDeviceInfo_DoesNotMakeHttpRequestIfDataCached() { var publishedDevice = new SsdpRootDevice() { Location = new Uri("http://192.168.1.100:1702/description"), CacheLifetime = TimeSpan.FromMinutes(1), DeviceType = "TestDeviceType", Uuid = System.Guid.NewGuid().ToString() }; var discoveredDevice = new DiscoveredSsdpDevice(); discoveredDevice.Usn = "test usn"; discoveredDevice.AsAt = DateTimeOffset.Now; discoveredDevice.CacheLifetime = publishedDevice.CacheLifetime; discoveredDevice.DescriptionLocation = publishedDevice.Location; var client = new MockHttpClient(publishedDevice.ToDescriptionDocument()); var device = discoveredDevice.GetDeviceInfo(client).GetAwaiter().GetResult(); client = new MockHttpClient(publishedDevice.ToDescriptionDocument()); device = discoveredDevice.GetDeviceInfo(client).GetAwaiter().GetResult(); Assert.IsNull(client.LastRequest); Assert.AreEqual(device.Uuid, publishedDevice.Uuid); Assert.AreEqual(device.DeviceType, publishedDevice.DeviceType); }
public DeviceViewModel(DiscoveredSsdpDevice discoveredDevice, SsdpDevice device) { this.discoveredDevice = discoveredDevice ?? throw new ArgumentNullException(nameof(discoveredDevice)); this.device = device ?? throw new ArgumentNullException(nameof(device)); State = DeviceState.NotConnected; PlayCommand = new RelayCommand(PlayAsync, () => CanPlay); PauseCommand = new RelayCommand(PauseAsync, () => CanPause); StopCommand = new RelayCommand(StopAsync, () => CanStop); UpdateCommandStatus(); deviceConnection = new EndpointConnection(Host); deviceCommunication = new EndpointCommunication(deviceConnection); var syncContext = SynchronizationContext.Current; deviceCommunication.StateChanged += (EndpointCommunication com, DeviceState newState) => { syncContext.Post((_) => { State = newState; UpdateCommandStatus(); }, null); }; deviceCommunication.PlayingTimeChanged += delegate { syncContext.Post((_) => { AudioDelay = TimeSpan.FromSeconds(Math.Max(0, (playWatch.Elapsed - deviceCommunication.PlayingTime).TotalSeconds)); }, null); }; }
public void DiscoveredDevice_IsExpired_ImmediatelyReportsTrueIfCacheLifetimeIsZero() { var discoveredDevice = new DiscoveredSsdpDevice(); discoveredDevice.AsAt = DateTimeOffset.Now; discoveredDevice.CacheLifetime = TimeSpan.Zero; Assert.IsTrue(discoveredDevice.IsExpired()); }
public void DiscoveredDevice_IsExpired_DoesNotImmediatelyReportTrue() { var discoveredDevice = new DiscoveredSsdpDevice(); discoveredDevice.AsAt = DateTimeOffset.Now; discoveredDevice.CacheLifetime = TimeSpan.FromSeconds(1); Assert.IsFalse(discoveredDevice.IsExpired()); }
private void DeviceFound(DiscoveredSsdpDevice device, bool isNewDevice, IpAddressInfo localIpAddress) { if (!NotificationTypeMatchesFilter(device)) { return; } OnDeviceAvailable(device, isNewDevice, localIpAddress); }
public void DiscoveredDevice_IsExpired_ReportsTrueAfterCacheLifetimeExpires() { var discoveredDevice = new DiscoveredSsdpDevice(); discoveredDevice.AsAt = DateTimeOffset.Now; discoveredDevice.CacheLifetime = TimeSpan.FromMilliseconds(100); System.Threading.Thread.Sleep(500); Assert.IsTrue(discoveredDevice.IsExpired()); }
private PythonDictionary ToPythonDictionary(DiscoveredSsdpDevice device) { var headersWrapper = new List(); foreach (var header in device.ResponseHeaders) { if (header.Value == null) { continue; } headersWrapper.Add(new PythonDictionary().WithValue("key", header.Key).WithValue("value", header.Value.FirstOrDefault())); } var deviceInfo = device.GetDeviceInfo().GetAwaiter().GetResult(); var servicesWrapper = new List(); foreach (var service in deviceInfo.Services) { servicesWrapper.Add(new PythonDictionary() .WithValue("control_url", service.ControlUrl.ToString()) .WithValue("event_sub_url", service.EventSubUrl.ToString()) .WithValue("full_service_type", service.FullServiceType) .WithValue("scpd_url", service.ScpdUrl.ToString()) .WithValue("service_id", service.ServiceId) .WithValue("service_type", service.ServiceType) .WithValue("service_type_namespace", service.ServiceTypeNamespace) .WithValue("service_version", service.ServiceVersion) .WithValue("uuid", service.Uuid)); } return(new PythonDictionary() .WithValue("usn", device.Usn) .WithValue("as_at", device.AsAt.ToString("O")) .WithValue("description_location", device.DescriptionLocation.ToString()) .WithValue("cache_lifetime", device.CacheLifetime.ToString("c")) .WithValue("notification_type", device.NotificationType) .WithValue("response_headers", headersWrapper) .WithValue("device_type", deviceInfo.DeviceType) .WithValue("device_type_namespace", deviceInfo.DeviceTypeNamespace) .WithValue("friendly_name", deviceInfo.FriendlyName) .WithValue("full_device_type", deviceInfo.FullDeviceType) .WithValue("device_version", deviceInfo.DeviceVersion) .WithValue("serial_number", deviceInfo.SerialNumber) .WithValue("udn", deviceInfo.Udn) .WithValue("upc", deviceInfo.Upc) .WithValue("uuid", deviceInfo.Uuid) .WithValue("manufacturer", deviceInfo.Manufacturer) .WithValue("manufacturer_url", deviceInfo.ManufacturerUrl.ToString()) .WithValue("model_description", deviceInfo.ModelDescription) .WithValue("model_name", deviceInfo.ModelName) .WithValue("model_number", deviceInfo.ModelNumber) .WithValue("services", servicesWrapper)); }
public void DiscoveredDevice_ToStringReturnsUsn() { var discoveredDevice = new DiscoveredSsdpDevice(); discoveredDevice.Usn = "test usn"; discoveredDevice.AsAt = DateTimeOffset.Now; discoveredDevice.CacheLifetime = TimeSpan.FromSeconds(1); System.Threading.Thread.Sleep(1000); Assert.AreEqual(discoveredDevice.Usn, discoveredDevice.ToString()); }
static SsdpDevice CreateSsdpDeviceModel(DiscoveredSsdpDevice discoveredSsdpDevice, Rssdp.SsdpDevice ssdpDevice) { return(new SsdpDevice { Usn = discoveredSsdpDevice.Usn, DescriptionLocation = discoveredSsdpDevice.DescriptionLocation?.ToString(), CacheLifetime = discoveredSsdpDevice.CacheLifetime, DeviceType = ssdpDevice.DeviceType, NotificationType = discoveredSsdpDevice.NotificationType, DeviceTypeNamespace = ssdpDevice.DeviceTypeNamespace, }); }
/// <summary> /// Raises the <see cref="DeviceUnavailable"/> event. /// </summary> /// <param name="device">A <see cref="DiscoveredSsdpDevice"/> representing the device that is no longer available.</param> /// <param name="expired">True if the device expired from the cache without being renewed, otherwise false to indicate the device explicitly notified us it was being shutdown.</param> /// <seealso cref="DeviceUnavailable"/> protected virtual void OnDeviceUnavailable(DiscoveredSsdpDevice device, bool expired) { if (this.IsDisposed) { return; } var handlers = this.DeviceUnavailable; if (handlers != null) { handlers(this, new DeviceUnavailableEventArgs(device, expired)); } }
/// <summary> /// Raises the <see cref="DeviceAvailable"/> event. /// </summary> /// <param name="device">A <see cref="DiscoveredSsdpDevice"/> representing the device that is now available.</param> /// <param name="isNewDevice">True if the device was not currently in the cahce before this event was raised.</param> /// <seealso cref="DeviceAvailable"/> protected virtual void OnDeviceAvailable(DiscoveredSsdpDevice device, bool isNewDevice) { if (this.IsDisposed) { return; } EventHandler <DeviceAvailableEventArgs> handlers = DeviceAvailable; if (handlers != null) { handlers(this, new DeviceAvailableEventArgs(device, isNewDevice)); } }
private async Task <ChromecastOptions> GetChromecastDetails(DiscoveredSsdpDevice foundDevice) { if (foundDevice == null) { return(null); } var fullDevice = await foundDevice.GetDeviceInfo(); var chromecast = new ChromecastOptions { Ip = foundDevice.DescriptionLocation.Host, Name = fullDevice.FriendlyName }; return(chromecast); }
/// <summary> /// Raises the <see cref="DeviceAvailable"/> event. /// </summary> /// <seealso cref="DeviceAvailable"/> protected virtual void OnDeviceAvailable(DiscoveredSsdpDevice device, bool isNewDevice, IpAddressInfo localIpAddress) { if (this.IsDisposed) { return; } var handlers = this.DeviceAvailable; if (handlers != null) { handlers(this, new DeviceAvailableEventArgs(device, isNewDevice) { LocalIpAddress = localIpAddress }); } }
private void DeviceFound(DiscoveredSsdpDevice device, bool isNewDevice) { // Don't raise the event if we've already done it for a cached // version of this device, and the cached version isn't // "significantly" different, i.e location and cachelifetime // haven't changed. var raiseEvent = false; if (!NotificationTypeMatchesFilter(device)) { return; } lock (_SearchResultsSynchroniser) { if (_SearchResults != null) { var existingDevice = FindExistingDeviceNotification(_SearchResults, device.NotificationType, device.Usn); if (existingDevice == null) { _SearchResults.Add(device); raiseEvent = true; } else { if (existingDevice.DescriptionLocation != device.DescriptionLocation || existingDevice.CacheLifetime != device.CacheLifetime) { _SearchResults.Remove(existingDevice); _SearchResults.Add(device); raiseEvent = true; } } } else { raiseEvent = true; } } if (raiseEvent) { OnDeviceAvailable(device, isNewDevice); } }
public void DiscoveredDevice_GetDeviceInfo_CreatesDefaultClient() { var publishedDevice = new SsdpRootDevice() { Location = new Uri("http://192.168.1.100:1702/description"), CacheLifetime = TimeSpan.FromMinutes(1), DeviceType = "TestDeviceType", Uuid = System.Guid.NewGuid().ToString() }; var discoveredDevice = new DiscoveredSsdpDevice(); discoveredDevice.Usn = "test usn"; discoveredDevice.AsAt = DateTimeOffset.Now; discoveredDevice.CacheLifetime = TimeSpan.FromSeconds(1); discoveredDevice.DescriptionLocation = publishedDevice.Location; var device = discoveredDevice.GetDeviceInfo().GetAwaiter().GetResult(); }
private void ProcessAliveNotification(HttpRequestMessage message, IpAddressInfo localIpAddress) { var location = GetFirstHeaderUriValue("Location", message); if (location != null) { var device = new DiscoveredSsdpDevice() { DescriptionLocation = location, Usn = GetFirstHeaderStringValue("USN", message), NotificationType = GetFirstHeaderStringValue("NT", message), CacheLifetime = CacheAgeFromHeader(message.Headers.CacheControl), AsAt = DateTimeOffset.Now, ResponseHeaders = message.Headers }; AddOrUpdateDiscoveredDevice(device, localIpAddress); } }
public void DeviceLocator_SearchAsync_FiltersNotificationsDuringSearch() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); var publishedDevice = CreateDeviceTree(); var publishedDevice2 = CreateDeviceTree(); deviceLocator.NotificationFilter = publishedDevice.Udn; deviceLocator.StartListeningForNotifications(); DiscoveredSsdpDevice device = null; bool newlyDiscovered = false; var receivedNotification = false; using (var eventSignal = new System.Threading.AutoResetEvent(false)) { deviceLocator.DeviceAvailable += (sender, args) => { device = args.DiscoveredDevice; newlyDiscovered = args.IsNewlyDiscovered; receivedNotification = true; eventSignal.Set(); }; var task = deviceLocator.SearchAsync(publishedDevice.Udn); server.MockReceiveBroadcast(GetMockAliveNotification(publishedDevice2)); server.WaitForMessageToProcess(5000); eventSignal.Reset(); server.MockReceiveBroadcast(GetMockAliveNotification(publishedDevice)); server.WaitForMessageToProcess(5000); eventSignal.WaitOne(10000); Assert.IsTrue(receivedNotification); var results = task.GetAwaiter().GetResult(); Assert.IsNotNull(results); Assert.AreEqual(1, results.Count()); Assert.IsTrue(results.First().Usn == device.Usn); } }
private void AddOrUpdateDiscoveredDevice(DiscoveredSsdpDevice device) { bool isNewDevice = false; lock (_Devices) { var existingDevice = FindExistingDeviceNotification(_Devices, device.NotificationType, device.Usn); if (existingDevice == null) { _Devices.Add(device); isNewDevice = true; } else { _Devices.Remove(existingDevice); _Devices.Add(device); } } DeviceFound(device, isNewDevice); }
public void DeviceLocator_Notifications_IgnoresNonNotifyRequest() { var server = new MockCommsServer(); var deviceLocator = new MockDeviceLocator(server); var receivedNotification = false; DiscoveredSsdpDevice device = null; bool expired = false; deviceLocator.DeviceUnavailable += (sender, args) => { device = args.DiscoveredDevice; expired = args.Expired; receivedNotification = true; }; deviceLocator.StartListeningForNotifications(); server.MockReceiveBroadcast(GetMockNonNotifyRequest()); server.WaitForMessageToProcess(10000); server.Dispose(); Assert.IsFalse(receivedNotification); }
private async Task <UpnpDeviceResponse> CreateUpnpDeviceAsync(DiscoveredSsdpDevice device) { var info = await device.GetDeviceInfo(); var headers = device.ResponseHeaders?.ToDictionary( h => h.Key, h => string.Join(" ", h.Value), StringComparer.OrdinalIgnoreCase); headers = headers ?? new Dictionary <string, string>(0); string server; string location; string usn = info.Udn; if (!headers.TryGetValue("location", out location)) { location = device.DescriptionLocation.AbsoluteUri; } if (!headers.TryGetValue("server", out server)) { server = string.Empty; } var response = new UpnpDeviceResponse(location, server, usn) { FriendlyName = info.FriendlyName, Manufacturer = info.Manufacturer, ModelName = info.ModelName }; foreach (var keyValuePair in headers) { response.AddHeader(keyValuePair.Key, keyValuePair.Value); } return(response); }
private void ProcessByeByeNotification(HttpRequestMessage message) { var notficationType = GetFirstHeaderStringValue("NT", message); if (!String.IsNullOrEmpty(notficationType)) { var usn = GetFirstHeaderStringValue("USN", message); if (!DeviceDied(usn, false)) { var deadDevice = new DiscoveredSsdpDevice() { AsAt = DateTime.UtcNow, CacheLifetime = TimeSpan.Zero, DescriptionLocation = null, NotificationType = GetFirstHeaderStringValue("NT", message), Usn = usn }; if (NotificationTypeMatchesFilter(deadDevice)) OnDeviceUnavailable(deadDevice, false); } ResetExpireCachedDevicesTimer(); } }
/// <summary> /// Raises the <see cref="DeviceUnavailable"/> event. /// </summary> /// <param name="device">A <see cref="DiscoveredSsdpDevice"/> representing the device that is no longer available.</param> /// <param name="expired">True if the device expired from the cache without being renewed, otherwise false to indicate the device explicitly notified us it was being shutdown.</param> /// <seealso cref="DeviceUnavailable"/> protected virtual void OnDeviceUnavailable(DiscoveredSsdpDevice device, bool expired) { if (this.IsDisposed) return; var handlers = this.DeviceUnavailable; if (handlers != null) handlers(this, new DeviceUnavailableEventArgs(device, expired)); }
private static void WriteOutDevices(DiscoveredSsdpDevice device) { Console.WriteLine(device.Usn + " - " + device.NotificationType + "\r\n\t @ " + device.DescriptionLocation); }
private void ProcessAliveNotification(HttpRequestMessage message) { var location = GetFirstHeaderUriValue("Location", message); if (location != null) { var device = new DiscoveredSsdpDevice() { DescriptionLocation = location, Usn = GetFirstHeaderStringValue("USN", message), NotificationType = GetFirstHeaderStringValue("NT", message), CacheLifetime = CacheAgeFromHeader(message.Headers.CacheControl), AsAt = DateTimeOffset.Now }; AddOrUpdateDiscoveredDevice(device); ResetExpireCachedDevicesTimer(); } }
private void DeviceFound(DiscoveredSsdpDevice device, bool isNewDevice) { // Don't raise the event if we've already done it for a cached // version of this device, and the cached version isn't // "significantly" different, i.e location and cachelifetime // haven't changed. var raiseEvent = false; if (!NotificationTypeMatchesFilter(device)) return; lock (_SearchResultsSynchroniser) { if (_SearchResults != null) { var existingDevice = FindExistingDeviceNotification(_SearchResults, device.NotificationType, device.Usn); if (existingDevice == null) { _SearchResults.Add(device); raiseEvent = true; } else { if (existingDevice.DescriptionLocation != device.DescriptionLocation || existingDevice.CacheLifetime != device.CacheLifetime) { _SearchResults.Remove(existingDevice); _SearchResults.Add(device); raiseEvent = true; } } } else raiseEvent = true; } if (raiseEvent) OnDeviceAvailable(device, isNewDevice); }
private void ProcessSearchResponseMessage(HttpResponseMessage message) { if (!message.IsSuccessStatusCode) return; var location = GetFirstHeaderUriValue("Location", message); if (location != null) { var device = new DiscoveredSsdpDevice() { DescriptionLocation = location, Usn = GetFirstHeaderStringValue("USN", message), NotificationType = GetFirstHeaderStringValue("ST", message), CacheLifetime = CacheAgeFromHeader(message.Headers.CacheControl), AsAt = DateTimeOffset.Now }; AddOrUpdateDiscoveredDevice(device); } }
private bool NotificationTypeMatchesFilter(DiscoveredSsdpDevice device) { return String.IsNullOrEmpty(this.NotificationFilter) || this.NotificationFilter == SsdpConstants.SsdpDiscoverAllSTHeader || device.NotificationType == this.NotificationFilter; }