Building a Cross-Platform USB Communication Layer in .NET MAUI

🔌 Building a Cross-Platform USB Communication Layer in .NET MAUI

Connecting Industrial Devices, Scanners, Scales, RFID Readers, and Serial Equipment

When most developers think about mobile applications, they imagine:

• REST APIs 🌐
• Bluetooth devices 📡
• Cloud services ☁️

But many enterprise applications interact directly with physical hardware.

Examples include:

• 📦 Barcode scanners
• ⚖️ Industrial scales
• 🏷️ RFID readers
• 🏭 PLC controllers
• 💳 Card readers
• 🖨️ Thermal printers
• 🔬 Laboratory equipment
• 🚚 Logistics hardware

The challenge is that USB communication is highly platform-specific.

Android, Windows, iOS, and MacCatalyst all expose different APIs and permissions for USB access.

In this guide, we'll design a cross-platform USB communication architecture using .NET MAUI that abstracts these differences and provides a unified development experience.

🧠 Why USB Still Matters

Many industries still rely heavily on USB-connected devices because they offer: ✅ Lower latency ✅ Better reliability ✅ No wireless interference ✅ Reduced power consumption ✅ Simpler deployment Especially in:

• Warehouses
• Manufacturing
• Healthcare
• Retail
• Logistics USB remains critical.

🌍 The Challenge

Every platform handles USB differently.

This means:

Device
 ↓
Platform API
 ↓
Application

must be abstracted.

🏗️ Architecture Overview

A clean architecture looks like:

UI
 ↓
IUsbService
 ↓
Transport Layer
 ↓
Platform Driver
 ↓
USB Device

This keeps business logic independent from hardware details.

📦 Common USB Device Types

Before writing code, it's important to understand the different device categories.

🔌 Serial Devices

Examples:

• Industrial scales
• PLCs
• Modems Communication:

COM Port

or

TTY Device

🖱️ HID Devices

Examples:

• Barcode scanners
• Keypads
• RFID readers Communication:

Human Interface Device

📦 Vendor-Specific Devices

Examples:

• Proprietary equipment
• Medical devices
• Custom controllers Usually require manufacturer SDKs.

🧩 Step 1: Create a USB Abstraction

public interface IUsbCommunicationService
{
    Task InitializeAsync();

    Task<IEnumerable<UsbDeviceInfo>> GetDevicesAsync();

    Task ConnectAsync(string deviceId);

    Task DisconnectAsync();

    Task SendAsync(byte[] data);

    event EventHandler<byte[]> DataReceived;
}

The UI should never care whether the device is:

• Serial
• HID
• WinUSB

📄 Device Model

public class UsbDeviceInfo
{
    public string DeviceId { get; set; }

    public string Name { get; set; }

    public int VendorId { get; set; }

    public int ProductId { get; set; }
}

⚙️ Dependency Injection

Register service:

builder.Services.AddSingleton<IUsbCommunicationService,
    UsbCommunicationService>();

📱 Platform Implementations

Create:

IUsbCommunicationService
       ↓
AndroidUsbService
WindowsUsbService
MacUsbService

🤖 Android USB Communication

Android uses:

UsbManager

Discover Devices

var manager =
    (UsbManager)Platform.CurrentActivity
        .GetSystemService(Context.UsbService);

var devices = manager.DeviceList;

Permissions

Android requires explicit user approval.

<uses-feature
    android:name="android.hardware.usb.host"/>

🪟 Windows USB Communication

Windows supports:

• Serial ports
• HID
• WinUSB

Enumerate Serial Ports

var ports =
    SerialPort.GetPortNames();

Open Connection

var port = new SerialPort(
    "COM3",
    9600);

port.Open();

🍏 MacCatalyst Support

MacCatalyst can access USB devices through native frameworks. However: ⚠️ Additional entitlements may be required. Architecture remains:

MAUI
 ↓
Native Bridge
 ↓
USB Device

🚫 What About iOS?

This is where things become complicated. Apple restricts generic USB communication. Usually you need:

• MFi-certified hardware
• External Accessory Framework Many devices simply won't work.

🔄 Reading Data

Most USB devices follow:

Device
 ↓
Bytes
 ↓
Application

Example

port.DataReceived += (_, _) =>
{
    var data = port.ReadExisting();

    ProcessData(data);
};

📡 Writing Data

Sending commands:

await _usbService.SendAsync(
    Encoding.ASCII.GetBytes(
        "START"));

🏷️ Example: Barcode Scanner

Many scanners behave like keyboards. Input:

123456789

Application receives:

123456789

through standard text events.

📦 Example: RFID Reader

Typical flow:

RFID Tag
 ↓
Reader
 ↓
USB
 ↓
MAUI App

Data Event

public event EventHandler<string>
    TagScanned;

⚖️ Example: Industrial Scale

Scale output:

Weight: 12.35kg

Parse:

var weight =
    decimal.Parse(rawValue);

🏭 Example: PLC Communication

Commands:

READ_STATUS
START
STOP
RESET

Send Command

await _usbService.SendAsync(
    Encoding.ASCII.GetBytes(
        "READ_STATUS"));

🔄 Message-Based Architecture

Instead of exposing raw bytes everywhere:

public interface IUsbMessage
{
}

Examples:

public class WeightReceivedMessage
{
    public decimal Weight { get; set; }
}

🧠 Device Driver Pattern

Avoid:

UI
 ↓
Raw USB

Use:

UI
 ↓
ScaleDriver
 ↓
USB Layer

📊 Driver Benefits

⚡ Performance Considerations

USB can generate huge amounts of data. Examples:

• Scanners
• Sensors
• Telemetry devices

Background Processing

Never process on UI thread.

await Task.Run(() =>
{
    ProcessMessage(data);
});

Buffer Incoming Data

ConcurrentQueue<byte[]>

can help avoid dropped packets.

🔐 Security Considerations

USB devices can be dangerous. Recommendations: ✅ Validate Vendor IDs ✅ Validate Product IDs ✅ Restrict supported devices ✅ Verify message formats

📡 Hot Plug Support

Devices may disconnect unexpectedly. Handle:

Connected
 ↓
Disconnected
 ↓
Reconnect

gracefully.

🧩 Device Discovery UI

A MAUI page can display:

🚚 Real-World Scenarios

Warehouse Applications

Devices:

• Barcode scanners
• RFID readers
• Label printers

Manufacturing

Devices:

• PLCs
• Sensors
• Controllers

Healthcare

Devices:

• Medical instruments
• Diagnostic equipment

Retail

Devices:

• Scanners
• Receipt printers
• Payment terminals

⚖️ USB vs Bluetooth

🔗 Reference Links

• https://learn.microsoft.com/dotnet/maui/
• https://developer.android.com/guide/topics/connectivity/usb
• https://learn.microsoft.com/dotnet/api/system.io.ports

🚀 Key Takeaways

✅ USB communication is still essential in many enterprise environments ✅ A platform abstraction layer keeps MAUI code clean ✅ Different device categories require different communication strategies ✅ Driver-based architectures scale much better than direct USB access ✅ USB enables integration with industrial, retail, healthcare, and logistics hardware

🔌 Final Thoughts

Most mobile development content focuses on cloud APIs and Bluetooth devices. Yet many real-world business applications still depend heavily on USB-connected hardware.

By building a proper cross-platform USB communication layer in .NET MAUI, you can bridge the gap between modern mobile applications and the physical devices that power industries such as manufacturing, healthcare, logistics, and retail.

The key is to design the architecture around abstractions and device drivers rather than platform APIs. Once that foundation exists, supporting new hardware becomes dramatically simpler—and your MAUI application becomes capable of interacting with an entire ecosystem of enterprise devices. 🚀🔌📦