Android Bluetooth help

Question

Android Bluetooth help

Eduardo Gomez 4,316

Hello, I have a Problem

I have a Bluetooth service for Android and is doesn't find any device

using Android.Bluetooth;
using Android.Content;
namespace SnapLabel.Platforms.Android {
    public class AndroidBluetoothScanner : IBluetoothService {
        public event Action<BluetoothDeviceModel>? DeviceFound;
        private readonly BluetoothAdapter _bluetoothAdapter = BluetoothAdapter.DefaultAdapter;
        private readonly HashSet<string> _seenDevices = [];
        private BroadcastReceiver? _receiver;
        public void StartScan() {
            if(_bluetoothAdapter is null || !_bluetoothAdapter.IsEnabled)
                return;
            if(!BluetoothPermissionHelper.EnsureBluetoothScanPermission()) {
                return;
            }
            _seenDevices.Clear();
            _receiver = new BluetoothScanReceiver(device => {
                if(_seenDevices.Add(device.Address)) {
                    DeviceFound?.Invoke(device);
                }
            });
            var filter = new IntentFilter(BluetoothDevice.ActionFound);
            Platform.AppContext.RegisterReceiver(_receiver, filter);
            _bluetoothAdapter.StartDiscovery();
        }
        public void StopScan() {
            if(_bluetoothAdapter?.IsDiscovering == true)
                _bluetoothAdapter.CancelDiscovery();
            if(_receiver != null) {
                Platform.AppContext.UnregisterReceiver(_receiver);
                _receiver = null;
            }
        }
        private class BluetoothScanReceiver(Action<BluetoothDeviceModel> onDeviceFound) : BroadcastReceiver {
            public override void OnReceive(Context context, Intent intent) {
                if(intent.Action != BluetoothDevice.ActionFound)
                    return;
                var device = (BluetoothDevice?)intent.GetParcelableExtra(BluetoothDevice.ExtraDevice);
                if(device == null || string.IsNullOrWhiteSpace(device.Name))
                    return;
                onDeviceFound(new BluetoothDeviceModel {
                    Name = device.Name,
                    Address = device.Address!,
                    FontIcon = GetFontIcon(device)
                });
            }
            private static string GetFontIcon(BluetoothDevice device) {
                var btClass = device.BluetoothClass;
                if(btClass == null)
                    return FontsConstants.Bluetooth;
                int major = (int)btClass.MajorDeviceClass;
                return major switch {
                    1 => FontsConstants.Computer,
                    2 => FontsConstants.Smartphone,
                    4 => FontsConstants.Headphones,
                    5 => FontsConstants.Mouse,
                    6 => FontsConstants.Print,
                    7 => FontsConstants.Keyboard,
                    _ => FontsConstants.Bluetooth_audio
                };
            }
        }
    }
}

I also Have a service for windows, and it finds things

using Windows.Devices.Bluetooth;
using Windows.Devices.Enumeration;
namespace SnapLabel.Platforms.Windows {
    /// <summary>
    /// Windows-specific implementation of IBluetoothService.
    /// Uses DeviceWatcher to discover nearby Bluetooth devices.
    /// </summary>
    public class WindowsBluetoothScanner : IBluetoothService {
        public event Action<BluetoothDeviceModel>? DeviceFound;
        private DeviceWatcher? _watcher;
        private bool _keepScanning;
        private readonly HashSet<string> _seenDevices = [];
        public void StartScan() {
            _keepScanning = true;
            _seenDevices.Clear();
            StartWatcher();
        }
        public void StopScan() {
            _keepScanning = false;
            if(_watcher != null &&
                (_watcher.Status == DeviceWatcherStatus.Started ||
                 _watcher.Status == DeviceWatcherStatus.EnumerationCompleted)) {
                _watcher.Stop();
                _watcher = null;
            }
        }
        private void StartWatcher() {
            string selector = "System.Devices.Aep.ProtocolId:=\"{e0cbf06c-cd8b-4647-bb8a-263b43f0f974}\"";
            _watcher = DeviceInformation.CreateWatcher(
                selector,
                [
                    "System.Devices.Aep.DeviceAddress",
                    "System.ItemNameDisplay"
                ],
                DeviceInformationKind.AssociationEndpoint
            );
            _watcher.Added += async (s, deviceInfo) => {
                string name = !string.IsNullOrWhiteSpace(deviceInfo.Name)
                    ? deviceInfo.Name
                    : deviceInfo.Properties.TryGetValue("System.Devices.Aep.DeviceAddress", out var addr)
                        ? addr?.ToString() ?? "Unknown"
                        : "Unknown";
                if(name.EndsWith("(Bluetooth)", StringComparison.OrdinalIgnoreCase))
                    name = name.Replace("(Bluetooth)", "").Trim();
                if(!_seenDevices.Add(name))
                    return;
                string fontIcon = FontsConstants.Bluetooth;
                try {
                    var btDevice = await BluetoothDevice.FromIdAsync(deviceInfo.Id);
                    if(btDevice != null) {
                        uint major = (uint)btDevice.ClassOfDevice.MajorClass;
                        fontIcon = major switch {
                            1 => FontsConstants.Computer,
                            2 => FontsConstants.Smartphone,
                            4 => FontsConstants.Headphones,
                            5 => FontsConstants.Mouse,
                            6 => FontsConstants.Print,
                            7 => FontsConstants.Keyboard,
                            _ => FontsConstants.Bluetooth_audio
                        };
                    }
                } catch(Exception ex) {
                    Debug.WriteLine($"[WARN] Could not get ClassOfDevice for {name}: {ex.Message}");
                }
                DeviceFound?.Invoke(new BluetoothDeviceModel {
                    Name = name,
                    Address = deviceInfo.Properties.TryGetValue("System.Devices.Aep.DeviceAddress", out var a)
                        ? a?.ToString() ?? ""
                        : "",
                    FontIcon = fontIcon
                });
            };
            _watcher.EnumerationCompleted += (s, e) => {
                Debug.WriteLine("[INFO] Enumeration completed. Watching for new devices...");
            };
            _watcher.Updated += (s, update) => {
                // Optional: handle property changes
            };
            _watcher.Removed += (s, update) => {
                // Optional: handle device removal
            };
            _watcher.Start();
        }
    }
}

Untitled video - Made with Clipchamp

As you can see my windows app is crazy fast, but android doesn't find anything

Anonymous

Hi Eduardo Gomez,

Thanks for sharing both your Windows and Android implementations. I reviewed your AndroidBluetoothScanner in detail, and have some recommendations:

Did you add permisstion in AndroidManifest.xml?

<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" />

And at runtime, you should request them before scanning:

if (Platform.CurrentActivity is Activity activity) {
    ActivityCompat.RequestPermissions(activity, new[] {
        Manifest.Permission.BluetoothScan,
        Manifest.Permission.BluetoothConnect,
        Manifest.Permission.AccessFineLocation
    }, 0);
}

Currently you’re only registering for BluetoothDevice.ActionFound. That means you don’t know if discovery has started or finished. Updating your registration makes it easier to confirm the lifecycle:

var filter = new IntentFilter();
filter.AddAction(BluetoothDevice.ActionFound);
filter.AddAction(BluetoothAdapter.ActionDiscoveryStarted);
filter.AddAction(BluetoothAdapter.ActionDiscoveryFinished);
Platform.AppContext.RegisterReceiver(_receiver, filter);

In your receiver you skip devices with no Name. On Android, many devices don’t broadcast their name until paired. A better approach is to use the address as a fallback. Here’s an example receiver generated by Copilot:

private class BluetoothScanReceiver(Action<BluetoothDeviceModel> onDeviceFound) : BroadcastReceiver {
    public override void OnReceive(Context context, Intent intent) {
        switch (intent.Action) {
            case BluetoothAdapter.ActionDiscoveryStarted:
                Android.Util.Log.Debug("BluetoothScan", "Discovery started...");
                break;

            case BluetoothAdapter.ActionDiscoveryFinished:
                Android.Util.Log.Debug("BluetoothScan", "Discovery finished.");
                break;

            case BluetoothDevice.ActionFound:
                var device = (BluetoothDevice?)intent.GetParcelableExtra(BluetoothDevice.ExtraDevice);
                if (device == null)
                    return;

                // Use name if available, otherwise fall back to address
                var name = !string.IsNullOrWhiteSpace(device.Name) ? device.Name : device.Address;

                onDeviceFound(new BluetoothDeviceModel {
                    Name = name,
                    Address = device.Address ?? string.Empty,
                    FontIcon = GetFontIcon(device)
                });
                break;
        }
    }

    private static string GetFontIcon(BluetoothDevice device) {
        var btClass = device.BluetoothClass;
        if (btClass == null)
            return FontsConstants.Bluetooth;
        int major = (int)btClass.MajorDeviceClass;
        return major switch {
            1 => FontsConstants.Computer,
            2 => FontsConstants.Smartphone,
            4 => FontsConstants.Headphones,
            5 => FontsConstants.Mouse,
            6 => FontsConstants.Print,
            7 => FontsConstants.Keyboard,
            _ => FontsConstants.Bluetooth_audio
        };
    }
}

Your current approach with BluetoothAdapter.StartDiscovery() will only find classic Bluetooth devices. If your test devices are BLE-only (such as earbuds, trackers, or many modern accessories), they won’t show up here. In that case, you’ll need to use BluetoothLeScanner.StartScan() instead.

I hope this helps you get things back on track quickly! If my suggestions can solve your issue, feel free to interact with the system accordingly!

Thank you!

Eduardo Gomez 4,316

it doesn't find any device

first ask for permissions

using Android;
using Android.Content.PM;
using AndroidX.Core.App;
using AndroidX.Core.Content;
namespace SnapLabel.Platforms.Android {
    public class BluetoothPermissionHelper {
        public static bool EnsureBluetoothScanPermission() {
            var activity = Platform.CurrentActivity!;
            var context = Platform.AppContext;
            if(ContextCompat.CheckSelfPermission(context, Manifest.Permission.BluetoothScan) != Permission.Granted) {
                ActivityCompat.RequestPermissions(activity, [
                Manifest.Permission.BluetoothScan,
                Manifest.Permission.BluetoothConnect,
                Manifest.Permission.AccessFineLocation
            ], 0);
                return false;
            }
            return true;
        }
    }
}

and then the class

using Android.Bluetooth;
using Android.Content;
namespace SnapLabel.Platforms.Android {
    public class AndroidBluetoothScanner : IBluetoothService {
        public event Action<BluetoothDeviceModel>? DeviceFound;
        private readonly BluetoothAdapter _bluetoothAdapter = BluetoothAdapter.DefaultAdapter;
        private readonly HashSet<string> _seenDevices = [];
        private BroadcastReceiver? _receiver;
        public void StartScan() {
            if(_bluetoothAdapter is null || !_bluetoothAdapter.IsEnabled)
                return;
            if(!BluetoothPermissionHelper.EnsureBluetoothScanPermission()) {
                return;
            }
            _seenDevices.Clear();
            _receiver = new BluetoothScanReceiver(device => {
                if(_seenDevices.Add(device.Address)) {
                    DeviceFound?.Invoke(device);
                }
            });
            var filter = new IntentFilter();
            filter.AddAction(BluetoothDevice.ActionFound);
            filter.AddAction(BluetoothAdapter.ActionDiscoveryStarted);
            filter.AddAction(BluetoothAdapter.ActionDiscoveryFinished);
            Platform.AppContext.RegisterReceiver(_receiver, filter);
            _bluetoothAdapter.StartDiscovery();
        }
        public void StopScan() {
            if(_bluetoothAdapter?.IsDiscovering == true)
                _bluetoothAdapter.CancelDiscovery();
            if(_receiver != null) {
                Platform.AppContext.UnregisterReceiver(_receiver);
                _receiver = null;
            }
        }
        private class BluetoothScanReceiver(Action<BluetoothDeviceModel> onDeviceFound) : BroadcastReceiver {
            public override void OnReceive(Context context, Intent intent) {
                switch(intent.Action) {
                    case BluetoothAdapter.ActionDiscoveryStarted:
                        Debug.WriteLine("BluetoothScan", "Discovery started...");
                        break;
                    case BluetoothAdapter.ActionDiscoveryFinished:
                        Debug.WriteLine("BluetoothScan", "Discovery finished.");
                        break;
                    case BluetoothDevice.ActionFound:
                        var device = (BluetoothDevice?)intent.GetParcelableExtra(BluetoothDevice.ExtraDevice);
                        if(device == null)
                            return;
                        // Use name if available, otherwise fall back to address
                        var name = !string.IsNullOrWhiteSpace(device.Name) ? device.Name : device.Address;
                        onDeviceFound(new BluetoothDeviceModel {
                            Name = name!,
                            Address = device.Address ?? string.Empty,
                            FontIcon = GetFontIcon(device)
                        });
                        break;
                }
            }
            private static string GetFontIcon(BluetoothDevice device) {
                var btClass = device.BluetoothClass;
                if(btClass == null)
                    return FontsConstants.Bluetooth;
                int major = (int)btClass.MajorDeviceClass;
                return major switch {
                    1 => FontsConstants.Computer,
                    2 => FontsConstants.Smartphone,
                    4 => FontsConstants.Headphones,
                    5 => FontsConstants.Mouse,
                    6 => FontsConstants.Print,
                    7 => FontsConstants.Keyboard,
                    _ => FontsConstants.Bluetooth_audio
                };
            }
        }
    }
}

Register Process

using FFImageLoading.Maui;
#if WINDOWS
using SnapLabel.Platforms.Windows;
#elif ANDROID
using SnapLabel.Platforms.Android;
#elif IOS
using SnapLabel.Platforms.iOS;
#elif MACCATALYST
using SnapLabel.Platforms.MacCatalyst;
#endif
namespace SnapLabel;
public static class MauiProgram {
    public static MauiApp CreateMauiApp() {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .UseFFImageLoading()
            .ConfigureSyncfusionCore()
            .ConfigureFonts(fonts => {
                fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                fonts.AddFont("MaterialIcons-Regular.ttf", "Mat");
            })
            .UseMauiCommunityToolkit();
#if DEBUG
        builder.Logging.AddDebug();
#endif
        builder.Services.AddSingleton<AppShell>();
        builder.Services.AddTransient<NewProductPage, NewProductPageViewModel>();
        builder.Services.AddSingleton<InventoryPage, InventoryPageViewModel>();
        builder.Services.AddSingleton(MediaPicker.Default);
        builder.Services.AddSingleton<IShellService, ShellService>();
        builder.Services.AddSingleton<DatabaseService>();
#if WINDOWS
        builder.Services.AddSingleton<IBluetoothService, WindowsBluetoothScanner>();
#elif ANDROID
        builder.Services.AddSingleton<IBluetoothService, AndroidBluetoothScanner>();
#elif IOS
        builder.Services.AddSingleton<IBluetoothService, IOSBluetoothScanner>();
#elif MACCATALYST
        builder.Services.AddSingleton<IBluetoothService, MacBluetoothScanner>();
#endif
        return builder.Build();
    }
}

and vm

namespace SnapLabel.ViewModels {
    public partial class InventoryPageViewModel : ObservableObject {
        #region Readonly and Static Fields
        private readonly IShellService _shellService;
        private readonly DatabaseService _databaseService;
        private readonly IBluetoothService? _bluetoothService;
        #endregion
        #region Observable Properties
        [ObservableProperty]
        public partial bool IsPopUpOpen { get; set; }
        public ObservableCollection<Product> Products { get; set; } = [];
        public ObservableCollection<BluetoothDeviceModel> Devices { get; set; } = [];
        [ObservableProperty]
        public partial BluetoothDeviceModel? SelectedDevice { get; set; }
        #endregion
        #region Constructor
        public InventoryPageViewModel(
            IShellService shellService,
            DatabaseService databaseService,
            IBluetoothService bluetoothService) {
            _shellService = shellService;
            _databaseService = databaseService;
            _bluetoothService = bluetoothService;
            _bluetoothService.DeviceFound += device => {
                MainThread.BeginInvokeOnMainThread(() => {
                    MainThread.BeginInvokeOnMainThread(() => {
                        Devices.Add(device);
                    });
                });
            };
        }
        #endregion
        #region Methods and Commands
        public async Task GetItems() {
            var items = await _databaseService.GetItemsAsync();
            Products.Clear();
            if(items.Count > 0) {
                foreach(var item in items) {
                    Products.Add(item);
                }
            }
        }
        [RelayCommand]
        void ClosePopUp() {
            IsPopUpOpen = false;
            _bluetoothService?.StopScan();
        }
        [RelayCommand]
        void ScanBluetooth() {
            IsPopUpOpen = true;
            Devices.Clear();
            _bluetoothService?.StartScan();
        }
        [RelayCommand]
        public async Task AddItem() {
            await _shellService.NavigateToAsync(nameof(NewProductPage));
        }
        #endregion
        [RelayCommand]
        void DeviceSelected(BluetoothDeviceModel bluetoothDeviceModel) {
        }
    }
}

Untitled video - Made with Clipchamp

Note I havent connected to a device, i am just going to finish this and then connect

Answer accepted by question author

0 additional answers

Your answer

Answer 1

Hello Eduardo,

Thank you for reaching out.

After reviewing everything, the issue is not with your code but with the environment you are testing in.

See https://stackoverflow.com/questions/22604305/how-to-use-android-emulator-for-testing-bluetooth-appl… for more details.

The standard Android Emulator does not have the capability to use your computer's physical Bluetooth adapter to scan for or connect to real-world Bluetooth devices. While your code can call the Bluetooth APIs without crashing, the emulator has no actual radio hardware to receive signals from nearby devices. This is why your scan is starting but never finding anything.

To properly test your Bluetooth scanning feature, you will need to deploy and run the application on a physical Android device.

Once you run it on a real phone or tablet, your current code should be able to discover Classic Bluetooth devices. As mentioned in the previous answer, if you also need to find modern accessories like earbuds or trackers (which use Bluetooth LE), you will eventually need to implement the BluetoothLeScanner as well. However, the first step is to move your testing to a physical device.

I hope this clears things up.

Share via

Android Bluetooth help

0 additional answers

Your answer