Support webusb as a backend

.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.wasm32-unknown-unknown]
+rustflags = "--cfg=web_sys_unstable_apis"

.github/workflows/rust.yml

@@ -2,9 +2,9 @@ name: Rust
 
 on:
   push:
-    branches: [ "main" ]
+    branches: ["main"]
   pull_request:
-    branches: [ "main" ]
+    branches: ["main"]
 
 env:
   CARGO_TERM_COLOR: always
@@ -21,31 +21,31 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        rust: ['stable', '1.76']
+        rust: ["stable", "1.80"]
 
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Install toolchain
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        toolchain: ${{ matrix.rust }}
-        override: true
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
+      - uses: actions/checkout@v3
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+      - name: Build
+        run: cargo build --verbose
+      - name: Run tests
+        run: cargo test --verbose
 
   build_android:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - name: Install toolchain
-      uses: dtolnay/rust-toolchain@stable
-      with:
-        targets: 'aarch64-linux-android, armv7-linux-androideabi'
-    - name: build
-      run: |
-        cargo build --target aarch64-linux-android --all-features
-        cargo build --target armv7-linux-androideabi --all-features
+      - uses: actions/checkout@v4
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: "aarch64-linux-android, armv7-linux-androideabi"
+      - name: build
+        run: |
+          cargo build --target aarch64-linux-android --all-features
+          cargo build --target armv7-linux-androideabi --all-features

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "rust-analyzer.check.targets": ["wasm32-unknown-unknown"],
+  "rust-analyzer.cargo.target": "wasm32-unknown-unknown",
+  "rust-analyzer.showUnlinkedFileNotification": false
+}

Cargo.toml

@@ -1,37 +1,70 @@
 [package]
 name = "nusb"
-version = "0.1.10"
+version = "0.1.12"
 description = "Cross-platform low-level access to USB devices in pure Rust"
 categories = ["hardware-support"]
 keywords = ["usb", "hardware"]
 authors = ["Kevin Mehall <[email protected]>"]
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 repository = "https://github.com/kevinmehall/nusb"
-rust-version = "1.76" # keep in sync with .github/workflows/rust.yml
+rust-version = "1.80"                                                       # keep in sync with .github/workflows/rust.yml
 
 [dependencies]
 atomic-waker = "1.1.2"
 futures-core = "0.3.29"
 log = "0.4.20"
 once_cell = "1.18.0"
 slab = "0.4.9"
+tracing = "0.1"
 
 [dev-dependencies]
 env_logger = "0.10.0"
 futures-lite = "1.13.0"
+pollster = { version = "0.4", features = ["macro"] }
 
-[target.'cfg(any(target_os="linux", target_os="android"))'.dependencies]
+[target.'cfg(all(any(target_os="linux", target_os="android"), not(target_arch="wasm32")))'.dependencies]
 rustix = { version = "0.38.17", features = ["fs", "event", "net"] }
 libc = "0.2.155"
 
 [target.'cfg(target_os="windows")'.dependencies]
-windows-sys = { version = "0.48.0", features = ["Win32_Devices_Usb", "Win32_Devices_DeviceAndDriverInstallation", "Win32_Foundation", "Win32_Devices_Properties", "Win32_Storage_FileSystem", "Win32_Security", "Win32_System_IO", "Win32_System_Registry", "Win32_System_Com"] }
+windows-sys = { version = "0.48.0", features = [
+    "Win32_Devices_Usb",
+    "Win32_Devices_DeviceAndDriverInstallation",
+    "Win32_Foundation",
+    "Win32_Devices_Properties",
+    "Win32_Storage_FileSystem",
+    "Win32_Security",
+    "Win32_System_IO",
+    "Win32_System_Registry",
+    "Win32_System_Com",
+] }
 
 [target.'cfg(target_os="macos")'.dependencies]
 core-foundation = "0.9.3"
 core-foundation-sys = "0.8.4"
 io-kit-sys = "0.4.0"
 
+[target.'cfg(target_arch="wasm32")'.dependencies]
+web-sys = { version = "*", features = [
+    "Document",
+    "Window",
+    "Navigator",
+    "Usb",
+    "UsbDevice",
+    "UsbDeviceRequestOptions",
+    "UsbConfiguration",
+    "UsbInterface",
+    "UsbAlternateInterface",
+    "UsbControlTransferParameters",
+    "UsbRequestType",
+    "UsbRecipient",
+    "UsbInTransferResult",
+    "UsbTransferStatus",
+    "UsbOutTransferResult",
+    "UsbDirection",
+] }
+wasm-bindgen-futures = { version = "*" }
+
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }

examples/blocking.rs

@@ -1,17 +1,21 @@
-use std::time::Duration;
-
+#[cfg(not(target_arch = "wasm32"))]
 use nusb::transfer::{Control, ControlType, Recipient};
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
 
-fn main() {
+#[pollster::main]
+async fn main() {
     env_logger::init();
     let di = nusb::list_devices()
+        .await
         .unwrap()
         .find(|d| d.vendor_id() == 0x59e3 && d.product_id() == 0x0a23)
         .expect("device should be connected");
 
     println!("Device info: {di:?}");
 
-    let device = di.open().unwrap();
+    #[cfg(not(target_arch = "wasm32"))]
+    let device = di.open().await.unwrap();
 
     // Linux can make control transfers without claiming an interface
     #[cfg(any(target_os = "linux", target_os = "macos"))]
@@ -48,36 +52,39 @@ fn main() {
         println!("{result:?}, {data:?}", data = &buf[..len]);
     }
 
-    // but we also provide an API on the `Interface` to support Windows
-    let interface = device.claim_interface(0).unwrap();
-
-    let result = interface.control_out_blocking(
-        Control {
-            control_type: ControlType::Vendor,
-            recipient: Recipient::Device,
-            request: 0x81,
-            value: 0x9999,
-            index: 0x9999,
-        },
-        &[1, 2, 3, 4, 5],
-        Duration::from_secs(1),
-    );
-    println!("{result:?}");
-
-    let mut buf = [0; 64];
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        // but we also provide an API on the `Interface` to support Windows
+        let interface = device.claim_interface(0).await.unwrap();
 
-    let len = interface
-        .control_in_blocking(
+        let result = interface.control_out_blocking(
             Control {
                 control_type: ControlType::Vendor,
                 recipient: Recipient::Device,
                 request: 0x81,
                 value: 0x9999,
                 index: 0x9999,
             },
-            &mut buf,
+            &[1, 2, 3, 4, 5],
             Duration::from_secs(1),
-        )
-        .unwrap();
-    println!("{data:?}", data = &buf[..len]);
+        );
+        println!("{result:?}");
+
+        let mut buf = [0; 64];
+
+        let len = interface
+            .control_in_blocking(
+                Control {
+                    control_type: ControlType::Vendor,
+                    recipient: Recipient::Device,
+                    request: 0x81,
+                    value: 0x9999,
+                    index: 0x9999,
+                },
+                &mut buf,
+                Duration::from_secs(1),
+            )
+            .unwrap();
+        println!("{data:?}", data = &buf[..len]);
+    }
 }

examples/bulk.rs

@@ -1,19 +1,22 @@
-use futures_lite::future::block_on;
 use nusb::transfer::RequestBuffer;
 
-fn main() {
+#[pollster::main]
+async fn main() {
     env_logger::init();
     let di = nusb::list_devices()
+        .await
         .unwrap()
         .find(|d| d.vendor_id() == 0x59e3 && d.product_id() == 0x0a23)
         .expect("device should be connected");
 
     println!("Device info: {di:?}");
 
-    let device = di.open().unwrap();
-    let interface = device.claim_interface(0).unwrap();
+    let device = di.open().await.unwrap();
+    let interface = device.claim_interface(0).await.unwrap();
 
-    block_on(interface.bulk_out(0x02, Vec::from([1, 2, 3, 4, 5])))
+    interface
+        .bulk_out(0x02, Vec::from([1, 2, 3, 4, 5]))
+        .await
         .into_result()
         .unwrap();
 
@@ -23,7 +26,7 @@ fn main() {
         while queue.pending() < 8 {
             queue.submit(RequestBuffer::new(256));
         }
-        let result = block_on(queue.next_complete());
+        let result = queue.next_complete().await;
         println!("{result:?}");
         if result.status.is_err() {
             break;

examples/control.rs

@@ -1,61 +1,70 @@
-use futures_lite::future::block_on;
 use nusb::transfer::{ControlIn, ControlOut, ControlType, Recipient};
 
-fn main() {
+#[pollster::main]
+async fn main() {
     env_logger::init();
     let di = nusb::list_devices()
+        .await
         .unwrap()
         .find(|d| d.vendor_id() == 0x59e3 && d.product_id() == 0x0a23)
         .expect("device should be connected");
 
     println!("Device info: {di:?}");
 
-    let device = di.open().unwrap();
+    let device = di.open().await.unwrap();
 
     // Linux can make control transfers without claiming an interface
     #[cfg(any(target_os = "linux", target_os = "macos"))]
     {
-        let result = block_on(device.control_out(ControlOut {
+        let result = device
+            .control_out(ControlOut {
+                control_type: ControlType::Vendor,
+                recipient: Recipient::Device,
+                request: 0x81,
+                value: 0x9999,
+                index: 0x9999,
+                data: &[1, 2, 3, 4],
+            })
+            .await;
+        println!("{result:?}");
+
+        let result = device
+            .control_in(ControlIn {
+                control_type: ControlType::Vendor,
+                recipient: Recipient::Device,
+                request: 0x81,
+                value: 0x9999,
+                index: 0x9999,
+                length: 256,
+            })
+            .await;
+        println!("{result:?}");
+    }
+
+    // but we also provide an API on the `Interface` to support Windows
+    let interface = device.claim_interface(0).await.unwrap();
+
+    let result = interface
+        .control_out(ControlOut {
             control_type: ControlType::Vendor,
             recipient: Recipient::Device,
             request: 0x81,
             value: 0x9999,
             index: 0x9999,
             data: &[1, 2, 3, 4],
-        }));
-        println!("{result:?}");
+        })
+        .await;
+    println!("{result:?}");
 
-        let result = block_on(device.control_in(ControlIn {
+    let result = interface
+        .control_in(ControlIn {
             control_type: ControlType::Vendor,
             recipient: Recipient::Device,
             request: 0x81,
             value: 0x9999,
             index: 0x9999,
             length: 256,
-        }));
-        println!("{result:?}");
-    }
-
-    // but we also provide an API on the `Interface` to support Windows
-    let interface = device.claim_interface(0).unwrap();
-
-    let result = block_on(interface.control_out(ControlOut {
-        control_type: ControlType::Vendor,
-        recipient: Recipient::Device,
-        request: 0x81,
-        value: 0x9999,
-        index: 0x9999,
-        data: &[1, 2, 3, 4],
-    }));
-    println!("{result:?}");
-
-    let result = block_on(interface.control_in(ControlIn {
-        control_type: ControlType::Vendor,
-        recipient: Recipient::Device,
-        request: 0x81,
-        value: 0x9999,
-        index: 0x9999,
-        length: 256,
-    }));
+        })
+        .await;
     println!("{result:?}");
 }