devicemanagement.cs

usbio using microsoft visual c# example

using System;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;
using Microsoft.VisualBasic;

namespace HID_Test_Application
{
	
	internal class DeviceManagement
	{
		
		// For detecting devices and receiving device notifications.
		
		// Used in error messages:
		const string ModuleName = "DeviceManagement";
		
		// For viewing results of API calls in debug.write statements:
		Debugging MyDebugging = new Debugging();
		
		
		internal bool DeviceNameMatch(Message m, string mydevicePathName)
		{
			
			// Purpose    : Compares two device path names. Used to find out if the device name
			//            : of a recently attached or removed device matches the name of a
			//            : device the application is communicating with.
			
			// Accepts    : m - a WM_DEVICECHANGE message. A call to RegisterDeviceNotification
			//            : causes WM_DEVICECHANGE messages to be passed to an OnDeviceChange routine.
			//            : mydevicePathName - a device pathname returned by SetupDiGetDeviceInterfaceDetail
			//            : in an SP_DEVICE_INTERFACE_DETAIL_DATA structure.
			
			// Returns    : True if the names match, False if not.
			
			try {
				DeviceManagementApiDeclarations.DEV_BROADCAST_DEVICEINTERFACE_1 DevBroadcastDeviceInterface = new DeviceManagementApiDeclarations.DEV_BROADCAST_DEVICEINTERFACE_1();
				DeviceManagementApiDeclarations.DEV_BROADCAST_HDR DevBroadcastHeader = new DeviceManagementApiDeclarations.DEV_BROADCAST_HDR();
				
				// The LParam parameter of Message is a pointer to a DEV_BROADCAST_HDR structure.
				Marshal.PtrToStructure(m.LParam, DevBroadcastHeader);
				
				if (DevBroadcastHeader.dbch_devicetype == DeviceManagementApiDeclarations.DBT_DEVTYP_DEVICEINTERFACE) {
					
					// The dbch_devicetype parameter indicates that the event applies to a device interface.
					// So the structure in LParam is actually a DEV_BROADCAST_INTERFACE structure,
					// which begins with a DEV_BROADCAST_HDR.
					
					// Obtain the number of characters in dbch_name by subtracting the 28 bytes
					// in the other members of the structure and dividing by 2 because there are
					// 2 bytes per character.
					int StringSize = System.Convert.ToInt32((DevBroadcastHeader.dbch_size - 28) / 2);
					
					// The dbcc_name parameter of DevBroadcastDeviceInterface contains the device name.
					// Trim dbcc_name to match the size of the string.
					DevBroadcastDeviceInterface.dbcc_name = new char[StringSize + 1];
					
					// Marshal data from the unmanaged block pointed to by m.LParam
					// to the managed object DevBroadcastDeviceInterface.
					Marshal.PtrToStructure(m.LParam, DevBroadcastDeviceInterface);
					
					// Store the device name in a String.
					string DeviceNameString = new string(DevBroadcastDeviceInterface.dbcc_name, 0, StringSize);
					
					Debug.WriteLine("Device Name = " + DeviceNameString);
					Debug.WriteLine("");
					
					// Compare the name of the newly attached device with the name of the device
					// the application is accessing (mydevicePathName).
					// Set ignorecase True.
					if (string.Compare(DeviceNameString, mydevicePathName, true) == 0) {
						// The name matches.
						return true;
					}
				}
				
			} catch (Exception ex) {
				HandleException(ModuleName + ":" + System.Reflection.MethodBase.GetCurrentMethod(), ex);
			}

      // It's a different device.
      return false;
		}
		
		
		internal bool FindDeviceFromGuid (System.Guid myGuid, ref string[] devicePathName)
		{
			
			// Purpose    : Uses SetupDi API functions to retrieve the device path name of an
			//            : attached device that belongs to an interface class.
			// Accepts    : myGuid - an interface class GUID.
			//            : devicePathName - a pointer to an array of strings that will contain
			//            : the device path names of attached devices.
			// Returns    : True if at least one device is found, False if not.
			
			// int DetailData;
			bool DeviceFound = false;
			IntPtr DeviceInfoSet;
			bool LastDevice = false;
			int BufferSize = 0;
			int MemberIndex = 0;
			// DeviceManagementApiDeclarations.SP_DEVINFO_DATA MyDeviceInfoData;
			DeviceManagementApiDeclarations.SP_DEVICE_INTERFACE_DETAIL_DATA MyDeviceInterfaceDetailData = new HID_Test_Application.DeviceManagementApiDeclarations.SP_DEVICE_INTERFACE_DETAIL_DATA();
			DeviceManagementApiDeclarations.SP_DEVICE_INTERFACE_DATA MyDeviceInterfaceData = new HID_Test_Application.DeviceManagementApiDeclarations.SP_DEVICE_INTERFACE_DATA();
			int Result = 0;
			string SingledevicePathName;
			bool Success = false;
			
			try
			{
				// ***
				// API function: SetupDiGetClassDevs
				// Purpose:
				// Retrieves a device information set for a specified group of devices.
				// SetupDiEnumDeviceInterfaces uses the device information set.
				// Accepts:
				// An interface class GUID
				// Null to retrieve information for all device instances
				// An optional handle to a top-level window (unused here)
				// Flags to limit the returned information to currently present devices
				// and devices that expose interfaces in the class specified by the GUID.
				// Returns:
				// A handle to a device information set for the devices.
				// ***
				
				DeviceInfoSet = 
          DeviceManagementApiDeclarations.SetupDiGetClassDevs (
            ref myGuid, 
            null, 
            0, 
            DeviceManagementApiDeclarations.DIGCF_PRESENT | DeviceManagementApiDeclarations.DIGCF_DEVICEINTERFACE);
				
				Debug.WriteLine(MyDebugging.ResultOfAPICall("SetupDiClassDevs"));
				
				DeviceFound = false;
				MemberIndex = 0;
				
				do {
					
					// Begin with 0 and increment through the device information set until
					// no more devices are available.
					
					// The cbSize element of the MyDeviceInterfaceData structure must be set to
					// the structure's size in bytes. The size is 28 bytes.
          MyDeviceInterfaceData.cbSize = 28;
          //Marshal.SizeOf(MyDeviceInterfaceData);
					
					// ***
					// API function:
					// SetupDiEnumDeviceInterfaces()
					// Purpose: Retrieves a handle to a SP_DEVICE_INTERFACE_DATA
					// structure for a device.
					// On return, MyDeviceInterfaceData contains the handle to a
					// SP_DEVICE_INTERFACE_DATA structure for a detected device.
					// Accepts:
					// A DeviceInfoSet returned by SetupDiGetClassDevs.
					// An interface class GUID.
					// An index to specify a device in a device information set.
					// A pointer to a handle to a SP_DEVICE_INTERFACE_DATA structure for a device.
					// Returns:
					// Non-zero on success, zero on True.
					// ***
					
					Result = 
            DeviceManagementApiDeclarations.SetupDiEnumDeviceInterfaces (
              DeviceInfoSet, 
              0, 
              ref myGuid, 
              MemberIndex, 
              ref MyDeviceInterfaceData);
					
					Debug.WriteLine(MyDebugging.ResultOfAPICall("SetupDiEnumDeviceInterfaces"));
					
					// Find out if a device information set was retrieved.
					
					if (Result == 0) {
						LastDevice = true;
					} else {
						// A device is present.
						Debug.WriteLine("  DeviceInfoSet for device #" + MemberIndex.ToString() + ": ");
						Debug.WriteLine("  cbSize = " + MyDeviceInterfaceData.cbSize.ToString());
						Debug.WriteLine("  InterfaceclassGuid = " + MyDeviceInterfaceData.InterfaceClassGuid.ToString());
						Debug.WriteLine("  Flags = " + MyDeviceInterfaceData.Flags.ToString("x"));
						
						// ***
						// API function:
						// SetupDiGetDeviceInterfaceDetail()
						// Purpose:
						// Retrieves an SP_DEVICE_INTERFACE_DETAIL_DATA structure
						// containing information about a device.
						// To retrieve the information, call this function twice.
						// The first time returns the size of the structure.
						// The second time returns a pointer to the data.
						// Accepts:
						// A DeviceInfoSet returned by SetupDiGetClassDevs
						// An SP_DEVICE_INTERFACE_DATA structure returned by SetupDiEnumDeviceInterfaces
						// A pointer to an SP_DEVICE_INTERFACE_DETAIL_DATA structure to receive information
						// about the specified interface.
						// The size of the SP_DEVICE_INTERFACE_DETAIL_DATA structure.
						// A pointer to a variable that will receive the returned required size of the
						// SP_DEVICE_INTERFACE_DETAIL_DATA structure.
						// A pointer to an SP_DEVINFO_DATA structure to receive information about the device.
						// Returns:
						// Non-zero on success, zero on failure.
						// ***
						
						Success = 
              DeviceManagementApiDeclarations.SetupDiGetDeviceInterfaceDetail(
                DeviceInfoSet, 
                ref MyDeviceInterfaceData,