Final fixes and test pages.

Author: galvesribeiro

README.md

@@ -1,2 +1,73 @@
-# WebUSB
-HTML5 WebUSB APIs for Microsoft ASP.Net Core Blazor
+# Canvas
+HTML5 WebUSB API implementation for Microsoft Blazor
+
+[![Build status](https://dotnet-ci.visualstudio.com/DotnetCI/_apis/build/status/Blazor-Extensions-WebUSB-CI?branch=master)](https://dotnet-ci.visualstudio.com/DotnetCI/_build/latest?definitionId=18&branch=master)
+[![Package Version](https://img.shields.io/nuget/v/Blazor.Extensions.WebUSB.svg)](https://www.nuget.org/packages/Blazor.Extensions.WebUSB)
+[![NuGet Downloads](https://img.shields.io/nuget/dt/Blazor.Extensions.WebUSB.svg)](https://www.nuget.org/packages/Blazor.Extensions.WebUSB)
+[![License](https://img.shields.io/github/license/BlazorExtensions/WebUSB.svg)](https://github.com/BlazorExtensions/WebUSB/blob/master/LICENSE)
+
+# Blazor Extensions
+
+Blazor Extensions are a set of packages with the goal of adding useful things to [Blazor](https://blazor.net).
+
+# Blazor Extensions WebUSB
+
+This package wraps [HTML5 WebUSB](https://wicg.github.io/webusb/) APIs. 
+
+# Installation
+
+```
+Install-Package Blazor.Extensions.WebUSB
+```
+
+# Sample
+
+## Usage
+
+- First add the USB services on Blazor `IServiceCollection`:
+
+```c#
+public void ConfigureServices(IServiceCollection services)
+{
+    services.UseWebUSB(); // Makes IUSB available to the DI container
+}
+```
+
+### To consume on your `.cshtml`:
+
+- On your `_ViewImports.cshtml` add the using entry:
+
+```c#
+@using Blazor.Extensions.WebUSB
+```
+
+- Then, on your `.cshtml` inject the `IUSB`:
+
+```c#
+@inject IUSB usb
+```
+
+And then use the `usb` object to interact with connected USB devices thru your Blazor application.
+
+### To inject on a `BlazorComponent` class:
+
+Define a property of type `IUSB` and mark it as `[Injectable]`:
+
+```c#
+[Inject] private IUSB _usb { get; set; }
+```
+
+Then use the `_usb` variable to interact with the connected USB devices.
+
+**Note**: For now, you have to call `await IUSB.Initialize()` once in your application. This is a temporary requirement and we are looking on a better way to automatically register to _Connect/Disconnect_ events.
+
+# Contributions and feedback
+
+Please feel free to use the component, open issues, fix bugs or provide feedback.
+
+# Contributors
+
+The following people are the maintainers of the Blazor Extensions projects:
+
+- [Attila Hajdrik](https://github.com/attilah)
+- [Gutemberg Ribiero](https://github.com/galvesribeiro)

src/Blazor.Extensions.WebUSB.JS/src/USBManager.ts

@@ -1,4 +1,4 @@
-import { USBDeviceFound, USBRequestDeviceOptions, ParseUSBDevice, USBConfiguration, USBInterface, USBDirection, USBInTransferResult, USBOutTransferResult, USBTransferStatus } from "./USBTypes";
+import { USBDeviceFound, USBRequestDeviceOptions, ParseUSBDevice, USBConfiguration, USBInterface, USBDirection, USBInTransferResult, USBOutTransferResult, USBTransferStatus, USBControlTransferParameters } from "./USBTypes";
 
 type DotNetReferenceType = {
 	invokeMethod<T>(methodIdentifier: string, ...args: any[]): T,
@@ -171,21 +171,21 @@ export class USBManager {
 	}
 
 	public TransferIn = (device: USBDeviceFound, endpointNumber: number, length: number): Promise<USBInTransferResult> => {
-
 		let usbDevice = this.GetUSBDevice(device);
 		return new Promise<USBInTransferResult>((resolve, reject) => {
 			if (!usbDevice) return reject("Device not connected");
-			console.log("In called:");
 
 			usbDevice.transferIn(endpointNumber, length)
 				.then(out => {
-					console.log(out.data.buffer);
 					resolve({
-						data: Array.prototype.slice.call(new Uint8Array(out.data.buffer)),
+						data: Array.prototype.slice.call(new Uint8Array(out.data.buffer)), // Hack to support Uint8Array to byte[] serialization.
 						status: out.status
 					});
 				})
-				.catch(err => reject(err));
+				.catch(err => {
+					console.error(err);
+					reject(err);
+				});
 		});
 	}
 
@@ -197,9 +197,54 @@ export class USBManager {
 
 			usbDevice.transferOut(endpointNumber, buffer)
 				.then(out => {
-					resolve({ bytesWritten: out.bytesWritten, status: out.status });
+					resolve({
+						bytesWritten: out.bytesWritten,
+						status: out.status
+					});
 				})
-				.catch(err => reject(err));
+				.catch(err => {
+					console.error(err);
+					reject(err);
+				});
+		});
+	}
+
+	public ControlTransferIn = (device: USBDeviceFound, setup: USBControlTransferParameters, length: number): Promise<USBInTransferResult> => {
+		let usbDevice = this.GetUSBDevice(device);
+		return new Promise<USBInTransferResult>((resolve, reject) => {
+			if (!usbDevice) return reject("Device not connected");
+
+			usbDevice.ControlTransferIn(setup, length)
+				.then(out => {
+					resolve({
+						data: Array.prototype.slice.call(new Uint8Array(out.data.buffer)), // Hack to support Uint8Array to byte[] serialization.
+						status: out.status
+					});
+				})
+				.catch(err => {
+					console.error(err);
+					reject(err);
+				});
+		});
+	}
+
+	public ControlTransferOut = (device: USBDeviceFound, setup: USBControlTransferParameters, data: any): Promise<USBOutTransferResult> => {
+		let usbDevice = this.GetUSBDevice(device);
+		return new Promise<USBOutTransferResult>((resolve, reject) => {
+			if (!usbDevice) return reject("Device not connected");
+			const buffer = data ? Uint8Array.from(data) : undefined;
+
+			usbDevice.controlTransferOut(setup, buffer)
+				.then(out => {
+					resolve({
+						bytesWritten: out.bytesWritten,
+						status: out.status
+					});
+				})
+				.catch(err => {
+					console.error(err);
+					reject(err);
+				});
 		});
 	}
 

src/Blazor.Extensions.WebUSB.JS/src/USBTypes.ts

@@ -26,10 +26,13 @@ export interface USBEndpoint { endpointNumber: number, direction: USBDirection,
 export interface USBTransferResult { status: USBTransferStatus }
 export interface USBInTransferResult extends USBTransferResult { data: any }
 export interface USBOutTransferResult extends USBTransferResult { bytesWritten: number }
+export interface USBControlTransferParameters { requestType: USBRequestType, recipient: USBRecipient, request: number, value: number, index: number }
 
 export enum USBDirection { "in", "out" }
 export enum USBEndpointType { "bulk", "interrupt", "isochronous" }
 export enum USBTransferStatus { "ok", "stall", "babble" }
+export enum USBRequestType { "standard", "class", "vendor" }
+export enum USBRecipient { "device", "interface", "endpoint", "other" }
 
 export function ParseUSBDevice(rawDevice: any): USBDeviceFound {
     return {

src/Blazor.Extensions.WebUSB/USB.cs

@@ -12,7 +12,7 @@ public class USB : IUSB
         private const string REMOVE_USB_METHOD = "BlazorExtensions.WebUSB.RemoveUSBEvents";
         private const string REQUEST_DEVICE_METHOD = "BlazorExtensions.WebUSB.RequestDevice";
         private const string GET_DEVICES_METHOD = "BlazorExtensions.WebUSB.GetDevices";
-
+        private bool _initialized = false;
         public event Action<USBDevice> OnDisconnect;
         public event Action<USBDevice> OnConnect;
 
@@ -65,6 +65,13 @@ public Task Disconnected(USBDevice device)
         }
 
         // TODO: Find out a more smart way to register to global connect/disconnect events from the WebUSB API regardless if there are subscribers to the events.
-        public Task Initialize() => JSRuntime.Current.InvokeAsync<object>(REGISTER_USB_METHOD, new DotNetObjectRef(this));
+        public async Task Initialize()
+        {
+            if (!this._initialized)
+            {
+                await JSRuntime.Current.InvokeAsync<object>(REGISTER_USB_METHOD, new DotNetObjectRef(this));
+                this._initialized = true;
+            }
+        }
     }
 }

src/Blazor.Extensions.WebUSB/USBControlTransferParameters.cs

@@ -0,0 +1,26 @@
+namespace Blazor.Extensions.WebUSB
+{
+    public static class USBRequestType
+    {
+        public const string Standard = "standard";
+        public const string Class = "class";
+        public const string Vendor = "vendor";
+    }
+
+    public static class USBRecipient
+    {
+        public const string Device = "device";
+        public const string Interface = "interface";
+        public const string Endpoint = "endpoint";
+        public const string Other = "other";
+    }
+
+    public class USBControlTransferParameters
+    {
+        public string RequestType { get; private set; }
+        public string Recipient { get; private set; }
+        public byte Request { get; private set; }
+        public int Value { get; private set; }
+        public int Index { get; private set; }
+    }
+}

src/Blazor.Extensions.WebUSB/USBDevice.Methods.cs

@@ -18,6 +18,8 @@ public static class USBDeviceMethods
         private const string SELECT_ALTERNATE_INTERFACE_METHOD = "BlazorExtensions.WebUSB.SelectAlternateInterface";
         private const string TRANSFER_OUT_METHOD = "BlazorExtensions.WebUSB.TransferOut";
         private const string TRANSFER_IN_METHOD = "BlazorExtensions.WebUSB.TransferIn";
+        private const string CONTROL_TRANSFER_OUT_METHOD = "BlazorExtensions.WebUSB.ControlTransferOut";
+        private const string CONTROL_TRANSFER_IN_METHOD = "BlazorExtensions.WebUSB.ControlTransferIn";
 
         internal static void AttachUSB(this USBDevice device, USB usb) => device.USB = usb;
         public static Task<USBDevice> Open(this USBDevice device) => JSRuntime.Current.InvokeAsync<USBDevice>(OPEN_DEVICE_METHOD, device);
@@ -54,6 +56,13 @@ public static Task<USBDevice> ClaimBulkInterface(this USBDevice device)
             return device.ClaimInterface(bulkInterface.InterfaceNumber);
         }
 
+        public static Task<USBDevice> ReleaseBulkInterface(this USBDevice device)
+        {
+            var bulkInterface = device.Configuration.Interfaces.FirstOrDefault(i => i.Alternates.Any(a => a.Endpoints.Any(e => e.Type == USBEndpointType.Bulk)));
+            if (bulkInterface == null) throw new InvalidOperationException("This devices doesn't have a Bulk interface");
+            return device.ReleaseInterface(bulkInterface.InterfaceNumber);
+        }
+
         public static Task<USBDevice> ReleaseInterface(this USBDevice device, USBInterface usbInterface)
         {
             if (usbInterface == null) throw new ArgumentNullException(nameof(usbInterface));
@@ -111,5 +120,15 @@ public static Task<USBOutTransferResult> TransferOut(this USBDevice device, byte
         {
             return JSRuntime.Current.InvokeAsync<USBOutTransferResult>(TRANSFER_OUT_METHOD, device, endpointNumber, data);
         }
+
+        public static Task<USBInTransferResult> ControlTransferIn(this USBDevice device, USBControlTransferParameters setup, long length)
+        {
+            return JSRuntime.Current.InvokeAsync<USBInTransferResult>(CONTROL_TRANSFER_IN_METHOD, device, setup, length);
+        }
+
+        public static Task<USBOutTransferResult> ControlTransferOut(this USBDevice device, USBControlTransferParameters setup, byte[] data)
+        {
+            return JSRuntime.Current.InvokeAsync<USBOutTransferResult>(CONTROL_TRANSFER_OUT_METHOD, device, setup, data);
+        }
     }
 }