private void OnDeviceChange(ref Message m)
{
if (!mEnabled)
{
return;
}
if (m.LParam.ToInt64() != 0) // ToInt32() only works on non-x64 platforms.
{
EventHandler <DeviceNotifyEventArgs> temp = OnDeviceNotify;
if (!ReferenceEquals(temp, null))
{
DeviceNotifyEventArgs args;
DevBroadcastHdr hdr = new DevBroadcastHdr();
Marshal.PtrToStructure(m.LParam, hdr);
switch (hdr.DeviceType)
{
case DeviceType.Port:
case DeviceType.Volume:
case DeviceType.DeviceInterface:
args = new WindowsDeviceNotifyEventArgs(hdr, m.LParam, (EventType)m.WParam.ToInt32());
break;
default:
args = null;
break;
}
if (!ReferenceEquals(args, null))
{
temp(this, args);
}
}
}
}
public static DeviceData GetDevice(IntPtr lParam)
{
DeviceData itemData = new DeviceData();
if ((int)lParam == 0)
{
return(itemData);
}
DevBroadcastHdr hdr = new DevBroadcastHdr();
Marshal.PtrToStructure(lParam, hdr);
itemData.DeviceType = ((DbtDeviceType)hdr.dbch_devicetype);
switch ((DbtDeviceType)hdr.dbch_devicetype)
{
case DbtDeviceType.DeviceInterface:
DevBroadcastDeviceinterfaceVariable devIf = new DevBroadcastDeviceinterfaceVariable();
// Convert lparam to DEV_BROADCAST_DEVICEINTERFACE structure
Marshal.PtrToStructure(lParam, devIf);
// Get the device path from the broadcast message
itemData.Data = new string(devIf.dbcc_name);
// Remove null-terminated data from the string
int pos = itemData.Data.IndexOf((char)0);
if (pos != -1)
{
itemData.Data = itemData.Data.Substring(0, pos);
}
break;
case DbtDeviceType.Port:
DevBroadcastPortVariable devPort = new DevBroadcastPortVariable();
// Convert lparam to DEV_BROADCAST_DEVICEINTERFACE structure
Marshal.PtrToStructure(lParam, devPort);
// Get the device path from the broadcast message
itemData.Data = new string(devPort.dbcc_name);
// Remove null-terminated data from the string
pos = itemData.Data.IndexOf((char)0);
if (pos != -1)
{
itemData.Data = itemData.Data.Substring(0, pos);
}
break;
case DbtDeviceType.Volume:
DevBroadcastVolume volume = new DevBroadcastVolume();
Marshal.PtrToStructure(lParam, volume);
itemData.Data = $"{((volume.dbcv_flags & (int) Dbtf.Media) == 1 ? "Media" : "Net")} {FirstDriveFromMask(volume.dbcv_unitmask)}";
break;
}
return(itemData);
}
public static bool IsNotificationForTargetDevice(Message m)
{
if (string.IsNullOrEmpty(devicepath))
{
return(false);
}
try
{
var devBroadcastDeviceInterface = new DevBroadcastDeviceinterface1();
var devBroadcastHeader = new DevBroadcastHdr();
try
{
Marshal.PtrToStructure(m.LParam, devBroadcastHeader);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(false);
}
// Is the notification event concerning a device interface?
if ((devBroadcastHeader.dbch_devicetype == Constants.DbtDevtypDeviceinterface))
{
// Get the device path name of the affected device
var stringSize = Convert.ToInt32((devBroadcastHeader.dbch_size - 32) / 2);
devBroadcastDeviceInterface.dbcc_name = new Char[stringSize + 1];
Marshal.PtrToStructure(m.LParam, devBroadcastDeviceInterface);
var deviceNameString = new string(devBroadcastDeviceInterface.dbcc_name, 0, stringSize);
// Compare the device name with our target device's pathname (strings are moved to lower case
return(string.Compare(deviceNameString.ToLower(), devicepath.ToLower(), StringComparison.OrdinalIgnoreCase) == 0);
}
}
catch (Exception ex)
{
Debug.WriteLine("usbGenericHidCommunication:isNotificationForTargetDevice() -> EXCEPTION: An unknown exception has occured!");
Debug.WriteLine(ex.Message);
return(false);
}
return(false);
}
public static DevBroadcastDeviceinterface GetDevBroadcastDeviceinterface(Message m)
{
DevBroadcastHdr hdr = GetDevBroadcastHdr(m);
if (hdr.DeviceType == DBT_DEVTYP_DEVICEINTERFACE)
{
DevBroadcastDeviceinterface0 dbi0 = (DevBroadcastDeviceinterface0)m.GetLParam(typeof(DevBroadcastDeviceinterface0));
DevBroadcastDeviceinterface dbi = new DevBroadcastDeviceinterface()
{
DeviceType = dbi0.DeviceType, ClassGuid = dbi0.ClassGuid
};
Byte[] bytes = new Byte[hdr.Size];
Marshal.Copy((IntPtr)m.LParam, bytes, 0, hdr.Size);
int offset = Marshal.SizeOf(dbi0) - 2;
dbi.Name = System.Text.Encoding.Unicode.GetString(bytes, offset, bytes.Length - offset);
return(dbi);
}
return(new DevBroadcastDeviceinterface());
}
private string GetDeviceName(Message m)
{
try
{
if (m.LParam == IntPtr.Zero)
{
return(null);
}
var devBroadcastDeviceInterface = new DevBroadcastDeviceinterface1();
var devBroadcastHeader = new DevBroadcastHdr();
try
{
Marshal.PtrToStructure(m.LParam, devBroadcastHeader);
}
catch (Exception ex)
{
LogHelper.Log.Error(ex.Message);
}
// Is the notification event concerning a device interface?
if ((devBroadcastHeader.dbch_devicetype == Constants.DbtDevtypDeviceinterface))
{
// Get the device path name of the affected device
var stringSize = Convert.ToInt32((devBroadcastHeader.dbch_size - 32) / 2);
devBroadcastDeviceInterface.dbcc_name = new Char[stringSize + 1];
Marshal.PtrToStructure(m.LParam, devBroadcastDeviceInterface);
var deviceNameString = new string(devBroadcastDeviceInterface.dbcc_name, 0, stringSize);
return(deviceNameString);
// Compare the device name with our target device's pathname (strings are moved to lower case
//return (string.Compare(deviceNameString.ToLower(), devicepath.ToLower(), StringComparison.OrdinalIgnoreCase) == 0);
}
}
catch (Exception ex)
{
LogHelper.Log.Error("GetDeviceName(Message m) -> 发生异常:", ex);
}
return(null);
}
/// <summary>
/// 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.
/// </summary>
///
/// <param name="m"> a WM_DEVICECHANGE message. A call to RegisterDeviceNotification
/// causes WM_DEVICECHANGE messages to be passed to an OnDeviceChange routine.. </param>
/// <param name="mydevicePathName"> a device pathname returned by
/// SetupDiGetDeviceInterfaceDetail in an SP_DEVICE_INTERFACE_DETAIL_DATA structure. </param>
///
/// <returns>
/// True if the names match, False if not.
/// </returns>
///
internal Boolean DeviceNameMatch(Message m, String mydevicePathName)
{
var devBroadcastDeviceInterface = new DevBroadcastDeviceinterface1();
var devBroadcastHeader = new DevBroadcastHdr();
// The LParam parameter of Message is a pointer to a DEV_BROADCAST_HDR structure.
Marshal.PtrToStructure(m.LParam, devBroadcastHeader);
if ((devBroadcastHeader.dbch_devicetype == DbtDevtypDeviceinterface))
{
// 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 32 bytes
// in the strucutre that are not part of dbch_name and dividing by 2 because there are
// 2 bytes per character.
var stringSize = Convert.ToInt32((devBroadcastHeader.dbch_size - 32) / 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.
var deviceNameString = new String(devBroadcastDeviceInterface.dbcc_name, 0, stringSize);
// Compare the name of the newly attached device with the name of the device
// the application is accessing (mydevicePathName).
// Set ignorecase True.
return(String.Compare(deviceNameString, mydevicePathName, StringComparison.OrdinalIgnoreCase) == 0);
}
return(false);
}
/// <summary>
/// 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.
/// </summary>
///
/// <param name="m"> a WM_DEVICECHANGE message. A call to RegisterDeviceNotification
/// causes WM_DEVICECHANGE messages to be passed to an OnDeviceChange routine.. </param>
/// <param name="mydevicePathName"> a device pathname returned by
/// SetupDiGetDeviceInterfaceDetail in an SP_DEVICE_INTERFACE_DETAIL_DATA structure. </param>
///
/// <returns>
/// True if the names match, False if not.
/// </returns>
///
internal Boolean DeviceNameMatch(Message m, String mydevicePathName)
{
var devBroadcastDeviceInterface = new DevBroadcastDeviceinterface1();
var devBroadcastHeader = new DevBroadcastHdr();
// The LParam parameter of Message is a pointer to a DEV_BROADCAST_HDR structure.
Marshal.PtrToStructure(m.LParam, devBroadcastHeader);
if ((devBroadcastHeader.dbch_devicetype == DbtDevtypDeviceinterface))
{
// 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 32 bytes
// in the strucutre that are not part of dbch_name and dividing by 2 because there are
// 2 bytes per character.
var stringSize = Convert.ToInt32((devBroadcastHeader.dbch_size - 32) / 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.
var deviceNameString = new String(devBroadcastDeviceInterface.dbcc_name, 0, stringSize);
// Compare the name of the newly attached device with the name of the device
// the application is accessing (mydevicePathName).
// Set ignorecase True.
return (String.Compare(deviceNameString, mydevicePathName, StringComparison.OrdinalIgnoreCase) == 0);
}
return false;
}
internal WindowsDeviceNotifyEventArgs(DevBroadcastHdr hdr, IntPtr ptrHdr, EventType eventType)
{
mBaseHdr = hdr;
mEventType = eventType;
mDeviceType = mBaseHdr.DeviceType;
switch (mDeviceType)
{
case DeviceType.Volume:
mVolume = new VolumeNotifyInfo(ptrHdr);
mObject = mVolume;
break;
case DeviceType.Port:
mPort = new PortNotifyInfo(ptrHdr);
mObject = mPort;
break;
case DeviceType.DeviceInterface:
mDevice = new UsbDeviceNotifyInfo(ptrHdr);
mObject = mDevice;
break;
}
}
