Minimum supported Bluetooth Version

[BikeBr0]

Just wondering if you have any guidance on Bluetooth version support. Specifically, I am learning that my app works on some windows PCs and not others. Bluetooth dongles are also not working. Do you have minimum version of Windows and/or Bluetooth version that a PC needs to support?

[fotiDim]

We test with Windows 10 and 11. Anything below that is uncharted territory.

Regarding Bluetooth version, I can run some tests with some old dongles and report back.

I would be nice if you could get the specs of your failing users.

[fotiDim]

OK this plugin supports Bluetooth Low Energy which was introduced with Bluetooth 4.0. Anything below that will definitely not work. I am currently testing successfully with those devices on Windows:

• EasyULT USB Bluetooth 5.0 Adapter (Bluetooth 5.0)
• ASUS USB-BT500 Adapter (Bluetooth 5.0)
• HP X2 G2 (built-in Bluetooth 4.2)
• Surface Pro (1st Gen) (built-in Bluetooth 4.0)

I will add some info in the readme although BLE implies Bluetooth >= 4.0.

[BikeBr0]

Hi @fotiDim, I'm finally back at this problem. I've created an EXE version of the example app bundled in the universal_ble repo.

Development Laptop - LENOVO_MT_21D8_BU_Think_FM_ThinkPad P15v Gen 3 (Windows 11 Pro)
Ble Availability is 'poweredOn' and I can find my peripheral in the scan results and connect to it. So far so good.

Test Laptop - LENOVO_MT_20CM_BU_Think_FM_ThinkPad X250 (Windows 10 Pro)
Ble Availability is 'unsupported' but I can still find my peripheral in the scan results and even connect to it.

When I modify the app to filter on my Service UUID, the Development Laptop continues to function as expected. However, the Test Laptop returns no scan results.

I was not able to install BLE Explorer on the Test Laptop as it just hangs on "Retrieving information from the Microsoft Store..."

[BikeBr0]

Also, I modified the example app to include a Switch that toggles service UUID filtering. By Default the filter is on and only my peripherals appear in the scan results. When I turn filtering off, all peripherals correctly appear in the results. However, clearing results from the UI and turning the filter back on does not seem to work as all nearby peripherals still appear in results. It would seem I need to call a clearResults method on the UniversalBle object... but I don't see a method like this. How do I clear previously found results?

[rohitsangwan01]

@BikeBr0 not sure how your filtering toggle works
but to get filtered/unfiltered results, we have to stop scan, and start again, only than filter will be effective, and there is no need to clear results or something on native level, because all results are directly coming from the bluetoothLEWatcher.Received events

[fotiDim]

@BikeBr0

Are you saying that your test laptop returns your peripheral but not when filtering? Are you using the same code on both laptops? If yes, I would use the debugger to see if/where it gets filtered. You can run your project through Visual Studio and put breakpoints on the native side.

---

Are you listening for availabilityChanges? Perhaps there is another state after unsupported.

UniversalBle.onAvailabilityChange = (state) {
  if (state == AvailabilityState.poweredOn) {
    UniversalBle.startScan();
  }
};

---

Please use Visual Studio to build and install BLEExplorer from source. We need to cross check with another app to rule out an OS or hardware issue.

[BikeBr0]

Hi @rohitsangwan01 I created an even simpler test case. Here is my custom startScan method in home.dart in the example app:

  Future<void> startScan() async {

    setState(() {
      _scanResults.clear();
      _isScanning = true;
    });        

    await UniversalBle.startScan(
      scanFilter: ScanFilter(
        withServices: ['<SERVICE_UUID_GOES_HERE>'],
        withManufacturerData: [],
      ),
    );
    await Future.delayed(const Duration(seconds: 5));
    await UniversalBle.stopScan();
    setState(() {
      _scanResults.clear();
    });
    await Future.delayed(const Duration(seconds: 1));

    await UniversalBle.startScan(
      scanFilter: ScanFilter(
        withServices: [],
        withManufacturerData: [],
      ),
    );
    await Future.delayed(const Duration(seconds: 5));
    UniversalBle.stopScan();
    setState(() {
      _isScanning = false;
    });        
  }

It simply calls UniversalBle.startScan with the service filter and correctly returns just 1 result. After a 5 second delay, and clearing the results from the UI, it scans without a filter and returns 3 results. This is the expected behaviour. However, after allowing startScan to complete, running startScan a second time returns 3 results immediately - when the filter is in effect. It seems to be returning stale results. This is on my development laptop (Lenovo P15v) which otherwise runs UniversalBle correctly.

[BikeBr0]

@fotiDim I am running the UniversalBle example app on both my development laptop and the test laptop but experiencing different results. The test laptop (now a Lenovo X270 running Windows 10 Pro) does not return any results when a service UUID is used to filter scan results, while my development laptop does. Incidently, my new Test Laptop does report BLE Availability as "poweredOn" consistently.

I was able to install the Bluetooth LE Explorer app on my Test Laptop and it does work. When I perform a scan I see my peripheral of interest and other devices nearby. However, I am unsure of how to filter on Service UUID using this app. Please advise.

[BikeBr0]

@fotiDim , I am not a C++ developer but did manage to get Visual Studio running in debug mode and can place break points in the BLE Scan Receiver . I can see that when UniversalBle.startScan (dart) is provided a Service UUID through withServices, all scan results evaluate to false at the isConnectable check (universal_ble_plugin.cpp). Does this help?

[rohitsangwan01]

@BikeBr0 are you filtering with just ServiceUUID or ManufacturerData as well ?
and on calling StopScan, we are clearing the bluetoothLeWatcher object, and creating new object on calling startScan, and only setting filter if servicesFilter is not empty

[BikeBr0]

@rohitsangwan01 just ServiceUUID. Here is my updated home.dart file that adds a Service toggle. Please review and let me know if I am making a mistake or if there is a bug in changing the filter. In between toggling the service filter I am using UI controls to stop the scan and clear results.

// ignore_for_file: use_build_context_synchronously

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:universal_ble/universal_ble.dart';
import 'package:universal_ble_example/data/capabilities.dart';
import 'package:universal_ble_example/data/mock_universal_ble.dart';
import 'package:universal_ble_example/home/widgets/scanned_devices_placeholder_widget.dart';
import 'package:universal_ble_example/home/widgets/scanned_item_widget.dart';
import 'package:universal_ble_example/data/permission_handler.dart';
import 'package:universal_ble_example/peripheral_details/peripheral_detail_page.dart';
import 'package:universal_ble_example/widgets/platform_button.dart';
import 'package:universal_ble_example/widgets/responsive_buttons_grid.dart';

class MyApp extends StatefulWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  State createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final _scanResults = <BleScanResult>[];
  bool _isScanning = false;
  bool _isQueueEnabled = true;
  bool _applyServiceFilter = false;

  AvailabilityState? bleAvailabilityState;
  final List<String> _services = [
    "00001800-0000-1000-8000-00805f9b34fb",
    "0000180f-0000-1000-8000-00805f9b34fb",
    "00002a00-0000-1000-8000-00805f9b34fb",
    "00002a01-0000-1000-8000-00805f9b34fb",
    "00002a19-0000-1000-8000-00805f9b34fb",
    "8000cc00-cc00-ffff-ffff-ffffffffffff",
    "8000dd00-dd00-ffff-ffff-ffffffffffff",
  ];

  @override
  void initState() {
    super.initState();

    /// Set mock instance for testing
    if (const bool.fromEnvironment('MOCK')) {
      UniversalBle.setInstance(MockUniversalBle());
    }

    /// Setup queue and timeout
    UniversalBle.queuesCommands = _isQueueEnabled;
    UniversalBle.timeout = const Duration(seconds: 10);

    UniversalBle.onAvailabilityChange = (state) {
      setState(() {
        bleAvailabilityState = state;
      });
    };

    UniversalBle.onScanResult = (result) {
      debugPrint("ScanResult: ${result.name}  ${result.services}");
      // debugPrint("${result.name} ${result.manufacturerData}");
      int index = _scanResults.indexWhere((e) => e.deviceId == result.deviceId);
      if (index == -1) {
        _scanResults.add(result);
      } else {
        if (result.name == null && _scanResults[index].name != null) {
          result.name = _scanResults[index].name;
        }
        _scanResults[index] = result;
      }
      setState(() {});
    };
  }

  Future<void> startScan() async {
    await UniversalBle.startScan(
      scanFilter: ScanFilter(
        // withServices: kIsWeb ? _services : [],
        withServices: _applyServiceFilter ? ['<ADD_DESIRED_SERVICEUUID_HERE>'] : [],
        withManufacturerData: [
          // ManufacturerDataFilter(
          //   companyIdentifier: 0x012D,
          //   data: Uint8List.fromList(
          //     [0x03, 0x00, 0x64, 0x00],
          //   ),
          // ),
        ],
      ),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Universal BLE'),
        elevation: 4,
        actions: [
          if (_isScanning)
            const Padding(
              padding: EdgeInsets.all(8.0),
              child: SizedBox(
                  width: 20,
                  height: 20,
                  child: CircularProgressIndicator.adaptive(
                    strokeWidth: 2,
                  )),
            ),
        ],
      ),
      body: Column(
        children: [
          Padding(
            padding: const EdgeInsets.all(8.0),
            child: ResponsiveButtonsGrid(
              children: [
                PlatformButton(
                  text: 'Start Scan',
                  onPressed: () async {
                    setState(() {
                      _scanResults.clear();
                      _isScanning = true;
                    });
                    try {
                      await startScan();
                    } catch (e) {
                      setState(() {
                        _isScanning = false;
                      });
                      ScaffoldMessenger.of(context).showSnackBar(
                        SnackBar(content: Text(e.toString())),
                      );
                    }
                  },
                ),
                PlatformButton(
                  text: 'Stop Scan',
                  onPressed: () async {
                    await UniversalBle.stopScan();
                    setState(() {
                      _isScanning = false;
                    });
                  },
                ),
                if (Capabilities.supportsBluetoothEnableApi &&
                    bleAvailabilityState == AvailabilityState.poweredOff)
                  PlatformButton(
                    text: 'Enable Bluetooth',
                    onPressed: () async {
                      bool isEnabled = await UniversalBle.enableBluetooth();
                      ScaffoldMessenger.of(context).showSnackBar(
                        SnackBar(content: Text("BluetoothEnabled: $isEnabled")),
                      );
                    },
                  ),
                if (Capabilities.requiresRuntimePermission)
                  PlatformButton(
                    text: 'Check Permissions',
                    onPressed: () async {
                      bool hasPermissions =
                          await PermissionHandler.arePermissionsGranted();
                      if (hasPermissions) {
                        ScaffoldMessenger.of(context).showSnackBar(
                          const SnackBar(content: Text("Permissions granted")),
                        );
                      }
                    },
                  ),
                if (Capabilities.supportsConnectedDevicesApi)
                  PlatformButton(
                    text: 'Connected Devices',
                    onPressed: () async {
                      var devices = await UniversalBle.getConnectedDevices(
                        withServices: _services,
                      );
                      if (devices.isEmpty) {
                        ScaffoldMessenger.of(context).showSnackBar(
                          const SnackBar(
                            content: Text("No Connected Devices Found"),
                          ),
                        );
                      }
                      setState(() {
                        _scanResults.clear();
                        _scanResults.addAll(devices);
                      });
                    },
                  ),
                PlatformButton(
                  text: _isQueueEnabled ? 'Disable Queue' : 'Enable Queue',
                  onPressed: () {
                    setState(() {
                      _isQueueEnabled = !_isQueueEnabled;
                      UniversalBle.queuesCommands = _isQueueEnabled;
                    });
                  },
                ),
                Switch(
                  value: _applyServiceFilter,
                  onChanged: (val) => setState(() {
                    _applyServiceFilter = val;
                  }),
                ),
                if (_scanResults.isNotEmpty)
                  PlatformButton(
                    text: 'Clear List',
                    onPressed: () {
                      setState(() {
                        _scanResults.clear();
                      });
                    },
                  ),
              ],
            ),
          ),
          Row(
            mainAxisAlignment: MainAxisAlignment.spaceBetween,
            children: [
              Padding(
                padding: const EdgeInsets.all(8.0),
                child: Text(
                  'Ble Availability : ${bleAvailabilityState?.name}',
                ),
              ),
            ],
          ),
          const Divider(color: Colors.blue),
          Expanded(
            child: _isScanning && _scanResults.isEmpty
                ? const Center(child: CircularProgressIndicator.adaptive())
                : !_isScanning && _scanResults.isEmpty
                    ? const ScannedDevicesPlaceholderWidget()
                    : ListView.separated(
                        itemCount: _scanResults.length,
                        separatorBuilder: (context, index) => const Divider(),
                        itemBuilder: (context, index) {
                          BleScanResult scanResult = _scanResults[index];
                          return ScannedItemWidget(
                            scanResult: scanResult,
                            onTap: () {
                              Navigator.push(
                                  context,
                                  MaterialPageRoute(
                                    builder: (context) => PeripheralDetailPage(
                                      scanResult.deviceId,
                                      scanResult.name ?? "Unknown Peripheral",
                                    ),
                                  ));
                              UniversalBle.stopScan();
                              setState(() {
                                _isScanning = false;
                              });
                            },
                          );
                        },
                      ),
          ),
        ],
      ),
    );
  }
}

[fotiDim]

@BikeBr0 we identified this as a bug. It will be fixed in 0.9.10.

[fotiDim]

@BikeBr0 0.9.10 is out

[BikeBr0]

A quick test shows this is working correctly now @fotiDim.