NET MAUI and Bluetooth LE: Building a Cross-Platform Device Communication Layer

🔵 .NET MAUI and Bluetooth LE

Building a Cross-Platform Device Communication Layer

Bluetooth Low Energy (BLE) has become a cornerstone for modern mobile applications—powering everything from fitness trackers ⌚ to IoT devices 🌐 and medical sensors 🏥. When working with .NET MAUI, integrating BLE introduces a classic challenge:

⚠️ How do you unify platform-specific BLE APIs into a clean, reusable, cross-platform communication layer?

In this guide, we’ll break down how to design and implement a robust BLE abstraction layer in .NET MAUI, leveraging best practices, architecture patterns, and real-world code examples.

🧠 Understanding the BLE Landscape

BLE is inherently platform-specific. Each OS provides its own API surface:

👉 This means:

• No unified API out of the box
• Different permission models 🔐
• Different lifecycle behaviors

🏗️ Architecture Overview

To avoid coupling your UI directly to BLE APIs, you should implement a layered architecture:

UI (Pages / ViewModels)  
        ↓  
IBluetoothService (Abstraction)  
        ↓  
Platform Implementations (Android / iOS / Windows)

🧩 Step 1: Define the Abstraction

Start with a clean interface that represents your BLE capabilities:

public interface IBluetoothService  
{  
    Task<IEnumerable<BleDevice>> ScanAsync();  
    Task ConnectAsync(string deviceId);  
    Task DisconnectAsync();  
    Task<byte[]> ReadAsync(string characteristicId);  
    Task WriteAsync(string characteristicId, byte[] data);  
}

📦 Device Model

public class BleDevice  
{  
    public string Id { get; set; }  
    public string Name { get; set; }  
}

🧩 Step 2: Shared Partial Class

public partial class BluetoothService : IBluetoothService  
{  
    public partial Task<IEnumerable<BleDevice>> ScanAsync();  
    public partial Task ConnectAsync(string deviceId);  
    public partial Task DisconnectAsync();  
    public partial Task<byte[]> ReadAsync(string characteristicId);  
    public partial Task WriteAsync(string characteristicId, byte[] data);  
}

🤖 Step 3: Android Implementation

#if ANDROID  
using Android.Bluetooth;  
using Android.Content;  
  
public partial class BluetoothService  
{  
    public partial async Task<IEnumerable<BleDevice>> ScanAsync()  
    {  
        var adapter = BluetoothAdapter.DefaultAdapter;  
  
        if (adapter == null || !adapter.IsEnabled)  
            return Enumerable.Empty<BleDevice>();  
  
        // Simplified scan logic  
        return new List<BleDevice>  
        {  
            new BleDevice { Id = "1", Name = "Android BLE Device" }  
        };  
    }  
}  
#endif

🍏 Step 4: iOS Implementation

#if IOS  
using CoreBluetooth;  
  
public partial class BluetoothService  
{  
    public partial async Task<IEnumerable<BleDevice>> ScanAsync()  
    {  
        // CoreBluetooth-based scanning (simplified)  
        return new List<BleDevice>  
        {  
            new BleDevice { Id = "1", Name = "iOS BLE Device" }  
        };  
    }  
}  
#endif

🪟 Step 5: Windows Implementation

#if WINDOWS  
using Windows.Devices.Bluetooth;  
  
public partial class BluetoothService  
{  
    public partial async Task<IEnumerable<BleDevice>> ScanAsync()  
    {  
        return new List<BleDevice>  
        {  
            new BleDevice { Id = "1", Name = "Windows BLE Device" }  
        };  
    }  
}  
#endif

⚙️ Optional: Using a Cross-Platform Library

Instead of building everything from scratch, you can leverage:

• Plugin.BLE

🧪 Example with Plugin.BLE

var adapter = CrossBluetoothLE.Current.Adapter;  
  
var devices = await adapter.GetSystemConnectedOrPairedDevices();  
  
foreach (var device in devices)  
{  
    Console.WriteLine(device.Name);  
}

🔐 Permissions & Configuration

🤖 Android

<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />  
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />  
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

🍏 iOS

<key>NSBluetoothAlwaysUsageDescription</key>  
<string>This app uses Bluetooth to connect to devices</string>

🪟 Windows

Handled via capabilities in the manifest.

⚖️ Custom Implementation vs Plugin

📊 Comparative Table

🧠 Best Practices

✅ 1. Always Abstract BLE

Never call native APIs directly from UI.

✅ 2. Handle Connectivity States

BLE is unstable by nature:

• Devices disconnect unexpectedly ⚠️
• Signal strength varies 📡

✅ 3. Use Async Patterns

BLE operations are inherently asynchronous:

await bluetoothService.ConnectAsync(deviceId);

✅ 4. Implement Retry Logic

for (int i = 0; i < 3; i++)  
{  
    try  
    {  
        await ConnectAsync(deviceId);  
        break;  
    }  
    catch  
    {  
        await Task.Delay(1000);  
    }  
}

✅ 5. Keep Battery in Mind 🔋

BLE is low energy—but misuse can drain battery:

• Avoid constant scanning
• Disconnect when not needed

🧱 Advanced Architecture (PRO Level)

Combine:

• Partial classes 🧩
• Dependency Injection 💉
• State management (MVVM)

builder.Services.AddSingleton<IBluetoothService, BluetoothService>();

🔗 Reference Links

• .NET MAUI documentation
• https://learn.microsoft.com/dotnet/maui/
• Plugin.BLE
• https://github.com/xabre/xamarin-bluetooth-le

🚀 Key Takeaways

• BLE is platform-dependent by nature
• Abstract everything behind an interface 🧩
• Use partials for clean separation
• Consider plugins for faster development ⚙️
• Design for instability and disconnections ⚠️

🔵 Final Thoughts

Building a BLE communication layer in .NET MAUI is not trivial—but done correctly, it becomes a powerful, reusable foundation for any IoT-enabled application. 👉 The goal is not just to make BLE work…
👉 It’s to make it clean, scalable, and production-ready. If you architect it right from the beginning, you’ll avoid one of the most painful refactors in cross-platform development. ⚡