private IntPtr HwndHandler(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam, ref bool handled)
{
// Only checking changed event since it gets called when devices are added and removed
// while remove notifications don't always get called.
if (msg == WmDevicechange)
{
if ((int)wparam == DbtDeviceArrival || (int)wparam == DbtDeviceRemoveComplete)
{
if (lparam != IntPtr.Zero)
{
//Get Device name
DevBroadcastDeviceInterface deviceInterface = (DevBroadcastDeviceInterface)Marshal.PtrToStructure(lparam, typeof(DevBroadcastDeviceInterface));
string deviceName = "";
deviceName = System.Text.Encoding.Unicode.GetString(deviceInterface.Name); //convert byte array into unicode
deviceName = deviceName.Replace("\0", string.Empty); //removes all unicode null "\0" charecters
if (deviceName.Contains("057e")) // nintendo VID = 057e
{
OnDevicesUpdated?.Invoke();
}
}
}
}
handled = false;
return(IntPtr.Zero);
}
/// <summary>
/// Register windows for notification
/// </summary>
/// <param name="windowHandle">Windows handle of the main window</param>
public void Register(IntPtr windowHandle)
{
#if WINDOWS_UWP
int size = Marshal.SizeOf <DevBroadcastDeviceInterface>();
#else
int size = Marshal.SizeOf(typeof(DevBroadcastDeviceInterface));
#endif
var deviceInterface = new DevBroadcastDeviceInterface();
deviceInterface.Size = (uint)size;
deviceInterface.DeviceType = (uint)UsbDeviceType.DeviceInterface; // DBT_DEVTYP_DEVICEINTERFACE;
deviceInterface.Reserved = 0;
deviceInterface.ClassGuid = InterfaceClassGuid;
IntPtr buffer = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(deviceInterface, buffer, true);
try
{
this.deviceEventHandle = NativeMethods.RegisterDeviceNotification(windowHandle, buffer, DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);
}
catch (Exception)
{
}
if (this.deviceEventHandle == IntPtr.Zero)
{
int error = Marshal.GetLastWin32Error();
}
Marshal.FreeHGlobal(buffer);
}
/// <summary>
/// Get the DevBroadcastDeviceInterface
/// </summary>
/// <param name="devBroadcastDeviceInterface">out DevBroadcastDeviceInterface</param>
/// <returns>bool true the value could be converted</returns>
public bool TryGetDevBroadcastDeviceInterface(out DevBroadcastDeviceInterface devBroadcastDeviceInterface)
{
if (_devBroadcastHeader.DeviceType != DeviceBroadcastDeviceType.DeviceInterface)
{
devBroadcastDeviceInterface = default;
return(false);
}
devBroadcastDeviceInterface = Marshal.PtrToStructure <DevBroadcastDeviceInterface>(_deviceBroadcastPtr);
return(true);
}
public void TestParse()
{
const string iPhoneDeviceName = @"\?\USB#VID_05AC&PID_1294&MI_00#0#{6bdd1fc6-810f-11d0-bec7-08002be2092f}";
var devBroadcastDeviceInterface = DevBroadcastDeviceInterface.Test(iPhoneDeviceName, DeviceInterfaceClass.StillImage);
Assert.Equal("1294", devBroadcastDeviceInterface.ProductId);
Assert.Equal("05AC", devBroadcastDeviceInterface.VendorId);
Assert.Equal("6bdd1fc6-810f-11d0-bec7-08002be2092f", devBroadcastDeviceInterface.DeviceClassGuid.ToString(), StringComparer.OrdinalIgnoreCase);
Assert.True(devBroadcastDeviceInterface.IsUsb);
Log.Info().WriteLine("More information: {0}", devBroadcastDeviceInterface.UsbDeviceInfoUri);
}
public void TestParse_2()
{
const string graphicsCard =
@"\?\PCI#VEN_10DE&DEV_1FB8&SUBSYS_09061028&REV_A1#4&32af3f68&0&0008#{1ca05180-a699-450a-9a0c-de4fbe3ddd89}";
var devBroadcastDeviceInterface = DevBroadcastDeviceInterface.Test(graphicsCard, DeviceInterfaceClass.DisplayDeviceArrival);
Assert.Equal("10DE", devBroadcastDeviceInterface.VendorId);
Assert.Equal("1ca05180-a699-450a-9a0c-de4fbe3ddd89", devBroadcastDeviceInterface.DeviceClassGuid.ToString(), StringComparer.OrdinalIgnoreCase);
Assert.Equal(@"PCI\VEN_10DE&DEV_1FB8&SUBSYS_09061028&REV_A1\4&32af3f68&0&0008", devBroadcastDeviceInterface.DisplayName);
Assert.True(devBroadcastDeviceInterface.IsPci);
Log.Info().WriteLine("More information: {0}", devBroadcastDeviceInterface.UsbDeviceInfoUri);
}
internal override IntPtr WindowProc(IntPtr hwnd, uint msg, IntPtr wParam, IntPtr lParam)
{
if (msg == WM_DEVICECHANGE)
{
var theEvent = wParam.ToInt64();
if (theEvent == DBT_DEVICEARRIVAL || theEvent == DBT_DEVICEREMOVECOMPLETE)
{
var devBroadcastMsg = new DevBroadcastDeviceInterface();
Marshal.PtrToStructure(lParam, devBroadcastMsg);
if (devBroadcastMsg.DeviceType != 0x05)
{
return(base.WindowProc(hwnd, msg, wParam, lParam));
}
if (theEvent == DBT_DEVICEARRIVAL)
{
Task.Run(() =>
{
if (currentContext == null)
{
Service.add(devBroadcastMsg.DevicePath);
}
else
{
currentContext.Post(delegate { Service.add(devBroadcastMsg.DevicePath); }, null);
}
});
}
else
{
var board = Service.Boards
.Where(x => x.Connection.DevicePath.Substring(3).ToLower() ==
devBroadcastMsg.DevicePath.Substring(3).ToLower())
.FirstOrDefault();
if (board != null)
{
Debug.WriteLine("Removing: " + board);
board.Connection.Dispose(); // kill the connection first
board.Dispose();
if (currentContext == null)
{
Service.Boards.Remove(board);
}
else
{
currentContext.Post(delegate { Service.Boards.Remove(board); }, null);
}
}
}
}
}
return(base.WindowProc(hwnd, msg, wParam, lParam));
}
public static void RegisterForDeviceNotification(IntPtr window)
{
var filter = new DevBroadcastDeviceInterface
{
size = (uint)Marshal.SizeOf(typeof(DevBroadcastDeviceInterface)),
deviceType = DBT_DEVTYP_DEVICEINTERFACE,
};
var result = RegisterDeviceNotification(window, ref filter, DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);
if (result == IntPtr.Zero)
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
}
private static DevBroadcastDeviceInterface CreateBroadcastDeviceInterface(Guid classGuid)
{
var dbi = new DevBroadcastDeviceInterface
{
DeviceType = DbtDeviceTypeDeviceInterface,
Reserved = 0,
ClassGuid = classGuid,
Name = 0
};
dbi.Size = Marshal.SizeOf(dbi);
return(dbi);
}
private static IntPtr RegisterDeviceNotification(DevBroadcastDeviceInterface dbi, IntPtr windowHandle)
{
var buffer = Marshal.AllocHGlobal(dbi.Size);
IntPtr handle;
try
{
Marshal.StructureToPtr(dbi, buffer, true);
handle = RegisterDeviceNotification(windowHandle, buffer, 0);
}
finally
{
// Free buffer
Marshal.FreeHGlobal(buffer);
}
return(handle);
}
public void RegisterDeviceNotification(
IntPtr windowHandle, Guid deviceInterfaceClass)
{
// Specifies which type of device to send notifications for. Here
// DeviceType is 5 which means notifications will be sent for all devices
// that are part of a specific device interface class (GUID).
// See NotificationFilter parameter of RegisterDeviceNotification docs
DevBroadcastDeviceInterface dbdi = new DevBroadcastDeviceInterface
{
DeviceType = 5,
Reserved = 0,
ClassGuid = deviceInterfaceClass,
Name = ""
};
dbdi.Size = Marshal.SizeOf(dbdi);
IntPtr filter = Marshal.AllocHGlobal(dbdi.Size);
Marshal.StructureToPtr(dbdi, filter, true);
NotificationHandle = RegisterDeviceNotification(windowHandle, filter, 0);
}
public void RegisterDeviceNotification(Window window)
{
//get main window handle and hook its message events
var source = HwndSource.FromHwnd(new WindowInteropHelper(window).Handle);
IntPtr windowHandle = source.Handle;
source.AddHook(HwndHandler);
//create filter to find bluetooth WmDevicechange messages only
DevBroadcastDeviceInterface deviceInterface = new DevBroadcastDeviceInterface
{
ClassGuid = GuidInterfaceHID,
DeviceType = DbtDevtypDeviceinterface,
};
deviceInterface.Size = Marshal.SizeOf(deviceInterface);
IntPtr buffer = Marshal.AllocHGlobal(deviceInterface.Size);
Marshal.StructureToPtr(deviceInterface, buffer, false);
//send messages of these filtered events to main window
notificationHandle = RegisterDeviceNotification(windowHandle, buffer, DEVICE_NOTIFY.WINDOWS_HANDLE);
}
public void RegisterDeviceNotification(Window window, Guid deviceClass, bool usbOnly = false)
{
var source = HwndSource.FromHwnd(new WindowInteropHelper(window).Handle);
source.AddHook(HwndHandler);
IntPtr windowHandle = source.Handle;
var deviceInterface = new DevBroadcastDeviceInterface
{
DeviceType = DbtDevtypDeviceinterface,
Reserved = 0,
ClassGuid = deviceClass,
Name = 0
};
deviceInterface.Size = Marshal.SizeOf(deviceInterface);
IntPtr buffer = Marshal.AllocHGlobal(deviceInterface.Size);
Marshal.StructureToPtr(deviceInterface, buffer, true);
notificationHandle = RegisterDeviceNotification(windowHandle, buffer, usbOnly ? 0 : DEVICE_NOTIFY_ALL_INTERFACE_CLASSES);
}
private static extern IntPtr RegisterDeviceNotification(IntPtr hRecipient, ref DevBroadcastDeviceInterface notificationFilter, uint flags);