/// <summary>
/// Creates a new service added event arguments.
/// </summary>
/// <param name="deviceArgs">The underlying device args from which the service came.</param>
/// <param name="service">The underlying COM service that was added.</param>
internal ServiceAddedEventArgs(DeviceAddedEventArgs deviceArgs, IUPnPService service)
{
mbInterfaceGuidAvailable = deviceArgs.InterfaceGuidAvailable;
if (mbInterfaceGuidAvailable) mgInterfaceGuid = deviceArgs.InterfaceGuid;
mdCOMDevice = deviceArgs.COMDevice;
msCOMService = service;
}
private void lvDevices_ItemActivate(object sender, EventArgs e)
{
// Browse the selected device
IUPnPDevice device = (IUPnPDevice)lvDevices.Items[lvDevices.SelectedIndices[0]].Tag;
BrowseDevice(device);
}
/// <summary>
/// Gets all readable info as text for a device.
/// </summary>
/// <param name="device">The com device to get the info for.</param>
/// <param name="indent">The indent for the information.</param>
/// <returns>The readable info for the device.</returns>
public static string ReadableInfo(this IUPnPDevice device, int indent = 0)
{
return(string.Format(
"{1}Name: {2} ({3}){0}" +
"{1}Description: {4}{0}" +
"{1}Manufacturer: {5} ({6}){0}" +
"{1}Model: {7} - {8} ({9}){0}" +
"{1}Serial: {10}{0}" +
"{1}Unique Device Name: {11}{0}" +
"{1}UPC: {12}{0}" +
"{1}Description URL: {13}{0}" +
"{1}Devices{14}" +
"{1}Services{15}",
Environment.NewLine,
new String(' ', indent * 4),
device.FriendlyName,
device.Type,
device.Description,
device.ManufacturerName,
device.ManufacturerURL,
device.ModelName,
device.ModelNumber,
device.ModelURL,
device.SerialNumber,
device.UniqueDeviceName,
device.UPC,
device.GetDocumentURL(),
device.Children.ReadableInfo(indent),
device.Services.ReadableInfo(indent)));
}
/// <summary>
/// Gets the root description for a com native device.
/// </summary>
/// <param name="device">The device to get root description for.</param>
/// <returns>The root description for the device.</returns>
internal RootDescription this[IUPnPDevice device]
{
get
{
RootDescription lrdDesc;
string lsKey = KeyFor(device);
if (Logging.Enabled)
Logging.Log(this, string.Format("Getting RootDescription from cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, device.FriendlyName, lsKey), 1);
try
{
if (!mdCache.TryGetValue(lsKey, out lrdDesc))
{
if (Logging.Enabled)
Logging.Log(this, "Cache missed");
lrdDesc = device.RootDeviceDescription();
if (Logging.Enabled)
Logging.Log(this, "Adding to cache");
mdCache[lsKey] = lrdDesc;
}
else
if (Logging.Enabled)
Logging.Log(this, "Cache hit");
return lrdDesc;
}
finally
{
if (Logging.Enabled)
Logging.Log(this, "Finished getting RootDescription from cache", -1);
}
}
}
/// <summary>
/// Creates a new service added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
/// <param name="interfaceGuid">The network interface guid.</param>
/// <param name="service">The service which was added.</param>
internal ServiceAddedEventArgs(IUPnPDevice device, Guid interfaceGuid, IUPnPService service)
{
mdCOMDevice = device;
msCOMService = service;
mgInterfaceGuid = interfaceGuid;
mbInterfaceGuidAvailable = true;
}
/// <summary>
/// Creates a new service added event arguments.
/// </summary>
/// <param name="deviceArgs">The underlying device args from which the service came.</param>
/// <param name="service">The underlying COM service that was added.</param>
internal ServiceAddedEventArgs(DeviceAddedEventArgs deviceArgs, IUPnPService service)
{
mbInterfaceGuidAvailable = deviceArgs.InterfaceGuidAvailable;
if (mbInterfaceGuidAvailable)
{
mgInterfaceGuid = deviceArgs.InterfaceGuid;
}
mdCOMDevice = deviceArgs.COMDevice;
msCOMService = service;
}
/// <summary>
/// Revmoves the cache for a com native device.
/// </summary>
/// <param name="device">The device to remove the cache for.</param>
internal void RemoveCacheFor(IUPnPDevice device)
{
string lsKey = KeyFor(device);
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Removing RootDescription cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, device.FriendlyName, lsKey));
}
mdCache.Remove(lsKey);
}
/// <summary>
/// Gets the device description for a device.
/// </summary>
/// <param name="device">The device to get the description for.</param>
/// <param name="rootDescription">The root description for the device.</param>
/// <returns>The device description or null if not found in the root description.</returns>
public static DeviceDescription Description(this IUPnPDevice device, RootDescription rootDescription)
{
if (rootDescription != null)
{
return(rootDescription.FindDevice(device.UniqueDeviceName));
}
else
{
return(null);
}
}
/// <summary>
/// Gets the document URL for a native com device.
/// </summary>
/// <param name="device">The native com device to get the document URL for.</param>
/// <returns>The URL for the document.</returns>
public static string GetDocumentURL(this IUPnPDevice device)
{
if (device is IUPnPDeviceDocumentAccess)
{
return(((IUPnPDeviceDocumentAccess)device).GetDocumentURL());
}
else
{
return(String.Empty);
}
}
/// <summary>
/// Gets the description for a service.
/// </summary>
/// <param name="service">The native com service.</param>
/// <param name="device">The native com device.</param>
/// <param name="rootDescription">The root description for the services device.</param>
/// <returns>The service description.</returns>
public static ServiceDescription Description(
this IUPnPService service, IUPnPDevice device, RootDescription rootDescription)
{
if (Logging.Enabled)
Logging.Log(service, String.Format("Getting ServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), 1);
try
{
DeviceServiceDescription ldsdDesc = service.DeviceServiceDescription(device, rootDescription);
if (ldsdDesc != null)
{
ServiceDescription lsdDesc = ldsdDesc.GetDescription(rootDescription);
if (lsdDesc != null)
{
if (Logging.Enabled)
{
if (Logging.Enabled)
Logging.Log(service, "ServiceDescription:", 1);
try
{
if (Logging.Enabled)
Logging.Log(service, lsdDesc.ToString());
}
finally
{
if (Logging.Enabled)
Logging.Log(service, "End ServiceDescription", -1);
}
}
}
else
if (Logging.Enabled)
Logging.Log(service, "ServiceDescription not found");
return lsdDesc;
}
else
{
if (Logging.Enabled)
Logging.Log(service, "Failed - Device Service Description Not Located");
return null;
}
}
finally
{
if (Logging.Enabled)
Logging.Log(service, String.Format("Finished getting ServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), -1);
}
}
/// <summary>
/// Removes the cache for a native dvice and service.
/// </summary>
/// <param name="device">The native device.</param>
/// <param name="service">The native service.</param>
internal void RemoveCacheFor(IUPnPDevice device, IUPnPService service)
{
string lsKey = KeyFor(device, service);
if (Logging.Enabled)
Logging.Log(this, string.Format("Getting ServiceDescription cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, service.Id, lsKey), 1);
ServiceDescription lsdDesc = null;
if (mdCache.TryGetValue(lsKey, out lsdDesc))
mdURLCache.Remove(lsdDesc.DocumentURL);
mdCache.Remove(lsKey);
}
/// <summary>
/// Gets the service description for a native device and service.
/// </summary>
/// <param name="device">The native device.</param>
/// <param name="service">The native service.</param>
/// <returns>The service description for the cache or null if not available.</returns>
internal ServiceDescription this[IUPnPDevice device, IUPnPService service]
{
get
{
ServiceDescription lsdDesc;
string lsKey = KeyFor(device, service);
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Getting ServiceDescription from cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, service.Id, lsKey), 1);
}
try
{
if (!mdCache.TryGetValue(lsKey, out lsdDesc))
{
if (Logging.Enabled)
{
Logging.Log(this, "Cache missed");
}
lsdDesc = service.Description(device, RootDescriptionCache.Cache[device.RootDevice]);
if (lsdDesc != null)
{
if (Logging.Enabled)
{
Logging.Log(this, "Adding to cache");
}
mdCache[lsKey] = lsdDesc;
mdURLCache[lsdDesc.DocumentURL] = lsdDesc;
}
else
if (Logging.Enabled)
{
Logging.Log(this, "Failed, nothing to add to cache");
}
}
return(lsdDesc);
}
finally
{
if (Logging.Enabled)
{
Logging.Log(this, "Finished getting ServiceDescription from cache", -1);
}
}
}
}
// Checks if device supports Content Directory service and opens a browser on it
private void BrowseDevice(IUPnPDevice device)
{
// Get service enumerator
IntPtr pE = device.Services._NewEnum;
IEnumUnknown pEnum = (IEnumUnknown)Marshal.GetObjectForIUnknown(pE);
Marshal.Release(pE);
// Enumerate services. Look for one that has ContentDirectory in its description
uint cItems;
IUPnPService svc = null;
IUPnPService svcContent = null;
bool couldBrowse = false;
while (pEnum.Next(1, out pE, out cItems) == 0 && cItems == 1)
{
svc = (IUPnPService)Marshal.GetObjectForIUnknown(pE);
Marshal.Release(pE);
object results;// = new object[3];
object retVal;
if (svc.ServiceTypeIdentifier.IndexOf("ContentDirectory", StringComparison.OrdinalIgnoreCase) >= 0)
{
// Check if the service supports Browse verb
// This is not really neccessary, but just a precaution
svcContent = svc;
int hr = svc.InvokeAction("Browse", new object[] { "0", "BrowseDirectChildren", "*", 0, 0, "" }, out results, out retVal);
if (hr == 0)
{
couldBrowse = true;
}
hr = 0;
}
}
if (!couldBrowse || svcContent == null)
{
MessageBox.Show("Found no browsable content");
}
else
{
// We have found the Content Directory
Browser browser = new Browser(svcContent);
browser.ShowDialog();
}
}
/// <summary>
/// Gets the root description for a com native device.
/// </summary>
/// <param name="device">The device to get root description for.</param>
/// <returns>The root description for the device.</returns>
internal RootDescription this[IUPnPDevice device]
{
get
{
RootDescription lrdDesc;
string lsKey = KeyFor(device);
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Getting RootDescription from cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, device.FriendlyName, lsKey), 1);
}
try
{
if (!mdCache.TryGetValue(lsKey, out lrdDesc))
{
if (Logging.Enabled)
{
Logging.Log(this, "Cache missed");
}
lrdDesc = device.RootDeviceDescription();
if (Logging.Enabled)
{
Logging.Log(this, "Adding to cache");
}
mdCache[lsKey] = lrdDesc;
}
else
if (Logging.Enabled)
{
Logging.Log(this, "Cache hit");
}
return(lrdDesc);
}
finally
{
if (Logging.Enabled)
{
Logging.Log(this, "Finished getting RootDescription from cache", -1);
}
}
}
}
public IntPtr DeviceAdded(int lFindData, IUPnPDevice pDevice)
{
try
{
Debug.WriteLine("DeviceAdded");
if (!fStopEvents)
{
m_frm._evtDeviceFound.Reset();
m_frm.Invoke(new DeviceFoundHandler(m_frm.DeviceFound), new object[] { this, Marshal.GetIUnknownForObject(pDevice) });
m_frm._evtDeviceFound.WaitOne();
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(IntPtr.Zero);
}
/// <summary>
/// Removes the cache for a native dvice and service.
/// </summary>
/// <param name="device">The native device.</param>
/// <param name="service">The native service.</param>
internal void RemoveCacheFor(IUPnPDevice device, IUPnPService service)
{
string lsKey = KeyFor(device, service);
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Getting ServiceDescription cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, service.Id, lsKey), 1);
}
ServiceDescription lsdDesc = null;
if (mdCache.TryGetValue(lsKey, out lsdDesc))
{
mdURLCache.Remove(lsdDesc.DocumentURL);
}
mdCache.Remove(lsKey);
}
/// <summary>
/// Adds devices from a devices child devices.
/// </summary>
/// <param name="device">The device to add the children for.</param>
/// <param name="interfaceGuid">The network interface Guid of the device or Guid.Empty if unknown.</param>
/// <param name="includingChildDevices">True to recursively get all devices or false to get immediate devices.</param>
internal void AddFrom(IUPnPDevice device, Guid interfaceGuid, bool includingChildDevices = false)
{
if (device.HasChildren)
{
foreach (UPnPDevice ldDevice in device.Children)
{
Add(new Device(ldDevice, interfaceGuid));
}
}
if (includingChildDevices)
{
foreach (IUPnPDevice ldDevice in device.Children)
{
AddFrom(ldDevice, interfaceGuid, includingChildDevices);
}
}
}
/// <summary>
/// Finds a device by UDN synchronously.
/// </summary>
/// <param name="udn">The UDN for the device (cannot be null or empty).</param>
/// <param name="addressFamily">The address family to search in. (Vista or above only).</param>
/// <returns>The device if one is found or null if not found.</returns>
/// <exception cref="System.ArgumentException">Thrown when udn is null or empty.</exception>
public static Device FindDeviceByUDN(
string udn, AddressFamilyFlags addressFamily = AddressFamilyFlags.IPvBoth)
{
if (String.IsNullOrEmpty(udn))
{
throw new ArgumentException("cannot be null or empty string", "udn");
}
IUPnPDevice ldDevice = FindNativeDeviceByUDN(udn, addressFamily);
if (ldDevice != null)
{
return(new Device(ldDevice, Guid.Empty));
}
else
{
return(null);
}
}
/// <summary>
/// Finds services for a device.
/// </summary>
/// <param name="device">The device to get the services for.</param>
/// <param name="interfaceGuid">The network guid for any new devices if available.</param>
/// <param name="serviceType">The service type for the services to search for.</param>
/// <returns>The services found.</returns>
public static Services FindServices(this IUPnPDevice device, Guid interfaceGuid, string serviceType)
{
Services lsServices = new Services();
foreach (IUPnPService lsService in device.Services)
{
if (lsService.ServiceTypeIdentifier == serviceType)
{
lsServices.Add(new Service(device, interfaceGuid, lsService));
}
}
foreach (IUPnPDevice ldDevice in device.Children)
{
lsServices.AddRange(ldDevice.FindServices(interfaceGuid, serviceType));
}
return(lsServices);
}
/// <summary>
/// Finds all (recursively) services of a certain type for a specific device by udn.
/// </summary>
/// <param name="udn">The udn of the device to search for services in (cannot be null or empty).</param>
/// <param name="serviceType">The partial or full service type of the service.</param>
/// <param name="addressFamily">The address family to search in. (Vista or above only).</param>
/// <returns>A list of services containing the found services on the device.</returns>
/// <exception cref="System.ArgumentException">Thrown when udn is null or empty.</exception>
public static Services FindServicesByUDN(
string udn, string serviceType,
AddressFamilyFlags addressFamily = AddressFamilyFlags.IPvBoth)
{
if (String.IsNullOrEmpty(udn))
{
throw new ArgumentException("cannot be null or empty string", "udn");
}
IUPnPDevice ldDevice = FindNativeDeviceByUDN(udn, addressFamily);
if (ldDevice != null)
{
return(ldDevice.FindServices(Guid.Empty, serviceType));
}
else
{
return(new Services());
}
}
// Handles the device discovery event
public void DeviceFound(object sender, IntPtr pDev)
{
// Marshal interface to the current thread
IUPnPDevice device = (IUPnPDevice)Marshal.GetObjectForIUnknown(pDev);
Debug.WriteLine("Found device: " + device.FriendlyName);
// Check if the device already in the list
// Devices are compared by UniqueDeviceName
foreach (ListViewItem item in lvDevices.Items)
{
if ((item.Tag as IUPnPDevice).UniqueDeviceName == device.UniqueDeviceName)
{
Debug.WriteLine("Already known");
return;
}
}
// Get device icon
// For simplicity we always ask for a 64x64 icon
string url;
Debug.WriteLine("Getting icon");
int ret = device.IconURL("image/png", 64, 64, 16, out url);
Image imgIcon = new Bitmap(64, 64);
if (ret == 0 && url != null)
{
imgIcon = GetIcon(url);
}
Debug.WriteLine("Adding");
il.Images.Add(imgIcon);
ListViewItem newItem = new ListViewItem(device.FriendlyName);
newItem.Tag = device;
newItem.ImageIndex = il.Images.Count - 1;
lvDevices.Items.Add(newItem);
_evtDeviceFound.Set();
}
/// <summary>
/// Gets the service description for a native device and service.
/// </summary>
/// <param name="device">The native device.</param>
/// <param name="service">The native service.</param>
/// <returns>The service description for the cache or null if not available.</returns>
internal ServiceDescription this[IUPnPDevice device, IUPnPService service]
{
get
{
ServiceDescription lsdDesc;
string lsKey = KeyFor(device, service);
if (Logging.Enabled)
Logging.Log(this, string.Format("Getting ServiceDescription from cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, service.Id, lsKey), 1);
try
{
if (!mdCache.TryGetValue(lsKey, out lsdDesc))
{
if (Logging.Enabled)
Logging.Log(this, "Cache missed");
lsdDesc = service.Description(device, RootDescriptionCache.Cache[device.RootDevice]);
if (lsdDesc != null)
{
if (Logging.Enabled)
Logging.Log(this, "Adding to cache");
mdCache[lsKey] = lsdDesc;
mdURLCache[lsdDesc.DocumentURL] = lsdDesc;
}
else
if (Logging.Enabled)
Logging.Log(this, "Failed, nothing to add to cache");
}
return lsdDesc;
}
finally
{
if (Logging.Enabled)
Logging.Log(this, "Finished getting ServiceDescription from cache", -1);
}
}
}
/// <summary>
/// Creates a new device added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
internal DeviceAddedEventArgs(IUPnPDevice device)
{
mbInterfaceGuidAvailable = false;
mdCOMDevice = device;
}
/// <summary>
/// Creates a new device.
/// </summary>
/// <param name="comDevice">The Native COM Device for which this device is linked to.</param>
/// <param name="interfaceGuid">The Network interface Guid ID for the device or Guid.Empty for unknown.</param>
internal Device(IUPnPDevice comDevice, Guid interfaceGuid)
{
mbInterfaceGuidAvailable = !interfaceGuid.Equals(Guid.Empty);
mgInterfaceGuid = interfaceGuid;
mdCOMDevice = comDevice;
}
int IUPnPDeviceFinderCallback.DeviceAdded(int lFindData, IUPnPDevice pDevice)
{
DeviceAdded((UPnPDevice)pDevice);
return 0;
}
/// <summary>
/// Adds services from a native device.
/// </summary>
/// <param name="device">The device to add the services for.</param>
/// <param name="interfaceGuid">The network interface Guid for the device.</param>
/// <param name="serviceType">The service type to add or null for all.</param>
/// <param name="includingChildDevices">True to add all child devices services.</param>
internal void AddFrom(IUPnPDevice device, Guid interfaceGuid, string serviceType = null, bool includingChildDevices = false)
{
if (Logging.Enabled)
{
Logging.Log(
this,
string.Format(
"Adding services for device: '{0}', ServiceType:'{1}' ChildDevices:'{2}'",
device.FriendlyName,
(serviceType == null ? "(null)" : serviceType),
includingChildDevices),
1);
}
try
{
if (Logging.Enabled)
{
Logging.Log(this, "Scanning services", 1);
}
try
{
foreach (IUPnPService lsService in device.Services)
{
try
{
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Service found: ID:'{0}', Type:'{1}'", lsService.Id, lsService.ServiceTypeIdentifier));
}
if (serviceType == null || lsService.ServiceTypeIdentifier == serviceType)
{
if (Logging.Enabled)
{
Logging.Log(this, "Service accepted - matched");
}
Add(new Service(device, interfaceGuid, lsService));
if (Logging.Enabled)
{
Logging.Log(this, "Service added");
}
}
else
if (Logging.Enabled)
{
Logging.Log(this, "Service rejected - not matched");
}
}
catch (Exception loE)
{
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Error occurred while adding service: '{0}'", loE.ToString()));
}
}
}
}
catch (Exception loE)
{
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Error occurred while scanning services: '{0}'", loE.ToString()));
}
}
if (Logging.Enabled)
{
Logging.Log(this, "Finished scanning services", -1);
}
if (includingChildDevices)
{
if (Logging.Enabled)
{
Logging.Log(this, "Scanning child devices", 1);
}
try
{
foreach (IUPnPDevice ldDevice in device.Children)
{
try
{
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Device found: Name:'{0}', UDN:'{1}'", ldDevice.FriendlyName, ldDevice.UniqueDeviceName));
}
AddFrom(ldDevice, interfaceGuid, serviceType, includingChildDevices);
}
catch (Exception loE)
{
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Error occurred while adding device: '{0}'", loE.ToString()));
}
}
}
}
catch (Exception loE)
{
if (Logging.Enabled)
{
Logging.Log(this, string.Format("Error occurred while scanning child devices: '{0}'", loE.ToString()));
}
}
if (Logging.Enabled)
{
Logging.Log(this, "Finished scanning child devices", -1);
}
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(this, "Finished adding services for device", -1);
}
}
}
/// <summary>
/// Creates a new services list from a native device.
/// </summary>
/// <param name="device">The device to add the services for.</param>
/// <param name="interfaceGuid">The network interface Guid for the device.</param>
/// <param name="serviceType">The service type to add or null for all.</param>
/// <param name="includingChildDevices">True to add all child devices services.</param>
internal Services(IUPnPDevice device, Guid interfaceGuid, string serviceType = null, bool includingChildDevices = false)
: base()
{
AddFrom(device, interfaceGuid, serviceType, includingChildDevices);
}
/// <summary>
/// Add a UPnPDevice to this device
/// </summary>
/// <param name="device">Device</param>
public void AddDevice(IUPnPDevice device)
{
AddDevice(device.GetUPnPDevice());
}
public int DeviceAdded(int lFindData, IUPnPDevice pDevice)
{
DeviceFound?.Invoke(lFindData, pDevice);
return(default(int));
}
int IUPnPDeviceFinderCallback.DeviceAdded(int lFindData, IUPnPDevice pDevice)
{
DeviceAdded((UPnPDevice)pDevice);
return(0);
}
/// <summary>
/// Creates a new list of devices from a devices child devices.
/// </summary>
/// <param name="device">The device to add the children for.</param>
/// <param name="interfaceGuid">The network interface Guid of the device or Guid.Empty if unknown.</param>
/// <param name="includingChildDevices">True to recursively get all devices or false to get immediate devices.</param>
internal Devices(IUPnPDevice device, Guid interfaceGuid, bool includingChildDevices = false)
: base()
{
AddFrom(device, interfaceGuid, includingChildDevices);
}
/// <summary>
/// Creates a new service object.
/// </summary>
/// <param name="comDevice">The immediate native device for the object.</param>
/// <param name="interfaceGuid">The network interface Guid or Guid.Empty for none.</param>
/// <param name="comService">The native service for the service.</param>
internal Service(IUPnPDevice comDevice, Guid interfaceGuid, IUPnPService comService)
: this(new Device(comDevice, interfaceGuid), comService)
{
}
/// <summary>
/// Creates a new device.
/// </summary>
/// <param name="comDevice">The Native COM Device for which this device is linked to.</param>
/// <param name="interfaceGuid">The Network interface Guid ID for the device or Guid.Empty for unknown.</param>
internal Device(IUPnPDevice comDevice, Guid interfaceGuid)
{
mbInterfaceGuidAvailable = !interfaceGuid.Equals(Guid.Empty);
mgInterfaceGuid = interfaceGuid;
mdCOMDevice = comDevice;
}
/// <summary>
/// Gets the root description for a device.
/// </summary>
/// <param name="device">The device to get the root description.</param>
/// <returns>The root description for the device.</returns>
public static RootDescription RootDeviceDescription(this IUPnPDevice device)
{
if (Logging.Enabled)
{
Logging.Log(device, String.Format("Getting RootDeviceDescription for {0}", device.FriendlyName), 1);
}
try
{
string lsURL = device.GetDocumentURL();
if (lsURL.Length > 0)
{
if (Logging.Enabled)
{
Logging.Log(device, String.Format("Getting Document URL: '{0}'", lsURL));
}
try
{
using (XmlTextReader lrReader = Utils.GetXMLTextReader(lsURL))
{
if (Logging.Enabled)
{
Logging.Log(device, "Finding start node");
}
while (lrReader.Read())
{
if (RootDescription.IsStartNodeFor(lrReader))
{
break;
}
}
if (RootDescription.IsStartNodeFor(lrReader))
{
if (Logging.Enabled)
{
Logging.Log(device, "Start node found, processing description");
}
return(new RootDescription(lsURL, lrReader));
}
else
{
if (Logging.Enabled)
{
Logging.Log(device, "Start node NOT found");
}
return(null);
}
}
}
catch (Exception loE)
{
if (Logging.Enabled)
{
Logging.Log(device, String.Format("Downloading and processing of URL failed with error: {0}", loE.ToString()));
}
throw;
}
}
else
{
if (Logging.Enabled)
{
Logging.Log(device, String.Format("Document URL Invalid: '{0}'", lsURL));
}
return(null);
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(device, System.String.Format("Finished getting RootDeviceDescription for {0}", device.FriendlyName), -1);
}
}
}
/// <summary>
/// Gets the key for a native device and service.
/// </summary>
/// <param name="device">The native device.</param>
/// <param name="service">The native service.</param>
/// <returns>The key for the device and service.</returns>
private string KeyFor(IUPnPDevice device, IUPnPService service)
{
return(device.RootDevice.UniqueDeviceName + "|" + service.Id);
}
/// <summary>
/// Creates a new device added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
/// <param name="baseArgs">The base args to get other event information from.</param>
internal DeviceAddedEventArgs(IUPnPDevice device, DeviceAddedEventArgs baseArgs)
{
mbInterfaceGuidAvailable = baseArgs.InterfaceGuidAvailable;
mgInterfaceGuid = baseArgs.mgInterfaceGuid;
mdCOMDevice = device;
}
//commands when device was found
internal void DeviceFound(int lFindData, IUPnPDevice pDevice)
{
DLNADevices.Add(new DLNADevice((UPnPDevice)pDevice));
}
/// <summary>
/// Creates a new device added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
/// <param name="interfaceGuid">The network interface guid.</param>
internal DeviceAddedEventArgs(IUPnPDevice device, Guid interfaceGuid)
{
mdCOMDevice = device;
mgInterfaceGuid = interfaceGuid;
mbInterfaceGuidAvailable = true;
}
/// <summary>
/// Gets the description for a service.
/// </summary>
/// <param name="service">The native com service.</param>
/// <param name="device">The native com device.</param>
/// <param name="rootDescription">The root description for the services device.</param>
/// <returns>The service description.</returns>
public static ServiceDescription Description(
this IUPnPService service, IUPnPDevice device, RootDescription rootDescription)
{
if (Logging.Enabled)
{
Logging.Log(service, String.Format("Getting ServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), 1);
}
try
{
DeviceServiceDescription ldsdDesc = service.DeviceServiceDescription(device, rootDescription);
if (ldsdDesc != null)
{
ServiceDescription lsdDesc = ldsdDesc.GetDescription(rootDescription);
if (lsdDesc != null)
{
if (Logging.Enabled)
{
if (Logging.Enabled)
{
Logging.Log(service, "ServiceDescription:", 1);
}
try
{
if (Logging.Enabled)
{
Logging.Log(service, lsdDesc.ToString());
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(service, "End ServiceDescription", -1);
}
}
}
}
else
if (Logging.Enabled)
{
Logging.Log(service, "ServiceDescription not found");
}
return(lsdDesc);
}
else
{
if (Logging.Enabled)
{
Logging.Log(service, "Failed - Device Service Description Not Located");
}
return(null);
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(service, String.Format("Finished getting ServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), -1);
}
}
}
/// <summary>
/// Gets the key for a native device and service.
/// </summary>
/// <param name="device">The native device.</param>
/// <param name="service">The native service.</param>
/// <returns>The key for the device and service.</returns>
private string KeyFor(IUPnPDevice device, IUPnPService service)
{
return device.RootDevice.UniqueDeviceName + "|" + service.Id;
}
/// <summary>
/// Gets the device service description for a service.
/// </summary>
/// <param name="service">The service to get the description for.</param>
/// <param name="device">The device to get the description for.</param>
/// <param name="rootDescription">The root description for the device.</param>
/// <returns>The device service description.</returns>
public static DeviceServiceDescription DeviceServiceDescription(
this IUPnPService service, IUPnPDevice device, RootDescription rootDescription)
{
if (Logging.Enabled)
Logging.Log(service, String.Format("Getting DeviceServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), 1);
try
{
if (Logging.Enabled)
{
if (Logging.Enabled)
Logging.Log(service, "Using RootDescription:", 1);
try
{
if (Logging.Enabled)
Logging.Log(service, rootDescription.ToString());
}
finally
{
if (Logging.Enabled)
Logging.Log(service, "End RootDescription", -1);
}
}
DeviceServiceDescription ldsdDesc = null;
if (rootDescription != null)
{
if (Logging.Enabled)
Logging.Log(service, string.Format("Finding device by UDN: '{0}'", device.UniqueDeviceName));
DeviceDescription lddDevice = rootDescription.FindDevice(device.UniqueDeviceName);
if (lddDevice != null)
{
if (Logging.Enabled)
Logging.Log(service, string.Format("Device Found, finding DeviceServiceDescription by Service ID: '{0}'", service.Id));
if (Logging.Enabled)
{
if (Logging.Enabled)
Logging.Log(service, "DeviceDescription:", 1);
try
{
if (Logging.Enabled)
Logging.Log(service, lddDevice.ToString());
}
finally
{
if (Logging.Enabled)
Logging.Log(service, "End DeviceDescription", -1);
}
}
lddDevice.DeviceServices.TryGetValue(service.Id, out ldsdDesc);
if (ldsdDesc != null)
{
if (Logging.Enabled)
{
if (Logging.Enabled)
Logging.Log(service, "DeviceServiceDescription found:", 1);
try
{
if (Logging.Enabled)
Logging.Log(service, ldsdDesc.ToString());
}
finally
{
if (Logging.Enabled)
Logging.Log(service, "End DeviceServiceDescription", -1);
}
}
}
else
if (Logging.Enabled)
Logging.Log(service, "DeviceServiceDescripton not found");
}
else
if (Logging.Enabled)
Logging.Log(service, "Device not found");
}
else
if (Logging.Enabled)
Logging.Log(service, "Invalid rootDescription parameter");
return ldsdDesc;
}
finally
{
if (Logging.Enabled)
Logging.Log(service, String.Format("Finished getting DeviceServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), -1);
}
}
/// <summary>
/// Gets the device service description for a service.
/// </summary>
/// <param name="service">The service to get the description for.</param>
/// <param name="device">The device to get the description for.</param>
/// <param name="rootDescription">The root description for the device.</param>
/// <returns>The device service description.</returns>
public static DeviceServiceDescription DeviceServiceDescription(
this IUPnPService service, IUPnPDevice device, RootDescription rootDescription)
{
if (Logging.Enabled)
{
Logging.Log(service, String.Format("Getting DeviceServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), 1);
}
try
{
if (Logging.Enabled)
{
if (Logging.Enabled)
{
Logging.Log(service, "Using RootDescription:", 1);
}
try
{
if (Logging.Enabled)
{
Logging.Log(service, rootDescription.ToString());
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(service, "End RootDescription", -1);
}
}
}
DeviceServiceDescription ldsdDesc = null;
if (rootDescription != null)
{
if (Logging.Enabled)
{
Logging.Log(service, string.Format("Finding device by UDN: '{0}'", device.UniqueDeviceName));
}
DeviceDescription lddDevice = rootDescription.FindDevice(device.UniqueDeviceName);
if (lddDevice != null)
{
if (Logging.Enabled)
{
Logging.Log(service, string.Format("Device Found, finding DeviceServiceDescription by Service ID: '{0}'", service.Id));
}
if (Logging.Enabled)
{
if (Logging.Enabled)
{
Logging.Log(service, "DeviceDescription:", 1);
}
try
{
if (Logging.Enabled)
{
Logging.Log(service, lddDevice.ToString());
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(service, "End DeviceDescription", -1);
}
}
}
lddDevice.DeviceServices.TryGetValue(service.Id, out ldsdDesc);
if (ldsdDesc != null)
{
if (Logging.Enabled)
{
if (Logging.Enabled)
{
Logging.Log(service, "DeviceServiceDescription found:", 1);
}
try
{
if (Logging.Enabled)
{
Logging.Log(service, ldsdDesc.ToString());
}
}
finally
{
if (Logging.Enabled)
{
Logging.Log(service, "End DeviceServiceDescription", -1);
}
}
}
}
else
if (Logging.Enabled)
{
Logging.Log(service, "DeviceServiceDescripton not found");
}
}
else
if (Logging.Enabled)
{
Logging.Log(service, "Device not found");
}
}
else
if (Logging.Enabled)
{
Logging.Log(service, "Invalid rootDescription parameter");
}
return(ldsdDesc);
}
finally
{
if (Logging.Enabled)
{
Logging.Log(service, String.Format("Finished getting DeviceServiceDescription for {0} -> {1}", device.FriendlyName, service.Id), -1);
}
}
}
/// <summary>
/// Creates a new service added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
/// <param name="service">The underlying COM service that was added.</param>
internal ServiceAddedEventArgs(IUPnPDevice device, IUPnPService service)
{
mbInterfaceGuidAvailable = false;
mdCOMDevice = device;
msCOMService = service;
}
/// <summary>
/// Creates a new service added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
/// <param name="service">The underlying COM service that was added.</param>
internal ServiceAddedEventArgs(IUPnPDevice device, IUPnPService service)
{
mbInterfaceGuidAvailable = false;
mdCOMDevice = device;
msCOMService = service;
}
/// <summary>
/// Revmoves the cache for a com native device.
/// </summary>
/// <param name="device">The device to remove the cache for.</param>
internal void RemoveCacheFor(IUPnPDevice device)
{
string lsKey = KeyFor(device);
if (Logging.Enabled)
Logging.Log(this, string.Format("Removing RootDescription cache for: '{0}' root of '{1}' key '{2}'", device.RootDevice.FriendlyName, device.FriendlyName, lsKey));
mdCache.Remove(lsKey);
}
/// <summary>
/// Creates a new service added event arguments.
/// </summary>
/// <param name="device">The underlying COM device that was added.</param>
/// <param name="interfaceGuid">The network interface guid.</param>
/// <param name="service">The service which was added.</param>
internal ServiceAddedEventArgs(IUPnPDevice device, Guid interfaceGuid, IUPnPService service)
{
mdCOMDevice = device;
msCOMService = service;
mgInterfaceGuid = interfaceGuid;
mbInterfaceGuidAvailable = true;
}
/// <summary>
/// Gets the key for a device.
/// </summary>
/// <param name="device">The com native device to get the key for.</param>
/// <returns>The key for a device.</returns>
internal string KeyFor(IUPnPDevice device)
{
return device.RootDevice.UniqueDeviceName;
}
