🐞 Notifications stop after a few seconds.

[Marshall-Moussavi]

Current behaviour:
Notifications on connectedSmartTrainer and connectedHeartRateMonitor are sent for ~5 seconds then stop. OnDisconnect
callback is not called.

Desired behaviour:
Notifications do not stop until device is disconnected.

Testing on iPhone 12 in Xcode 14.2 with Capacitor-community/ble 3.1.1, Capacitor 5.5.1

*here is the minimal reproducible example

// BleClient = CapacitorBluetooth

  useEffect(() => {
    let scanInterval;
    if (centralBluetoothState === "poweredOff") {
      setConnectedSmartTrainer(null);
      setConnectedHeartRateMonitor(null);
      setConnectedPowerMeter(null);
      setDevices([]);
    }
    if (centralBluetoothState === "poweredOn") {
      const startDeviceScan = () => {
        const HEART_RATE_UUID = numberToUUID(0x180d);
        const POWER_UUID = numberToUUID(0x1818);
        const FITNESS_MACHINE_UUID = numberToUUID(0x1826);
        const options = {
          services: [HEART_RATE_UUID, POWER_UUID, FITNESS_MACHINE_UUID],
          allowDuplicates: false,
        };
        CapacitorBluetooth.requestLEScan(options, (result) => {
          let type;
          if (result.uuids.includes(HEART_RATE_UUID)) {
            type = "Heart Rate Monitor";
          } else if (result.uuids.includes(FITNESS_MACHINE_UUID)) {
            type = "Smart Trainer";
          } else if (result.uuids.includes(POWER_UUID)) {
            type = "Power Meter";
          } else {
            type = "Unknown";
          }

          const device = {
            id: result.device.deviceId,
            name: result.localName,
            state: "disconnected",
            type: type,
          };

          setDevices((prevDevices) => {
            const deviceExists = prevDevices.some(
              (dev) => dev.id === device.id
            );
            if (!deviceExists) {
              return [...prevDevices, device];
            }

            return prevDevices;
          });
        }).catch((error) => {
          console.error("Error starting BLE scan:", error);
        });
      };

      const stopDeviceScan = () => {
        if (
          typeof window !== "undefined" &&
          window.Capacitor &&
          (router.pathname.includes("devices") ||
            router.pathname.includes("workout-player"))
        ) {
          CapacitorBluetooth.stopLEScan()
            .then(() => {
              // console.log("Stopped BLE scan");
            })
            .catch((error) => {
              // console.error("Error stopping BLE scan:", error);
            });
        }
      };

      const continuousScan = () => {
        startDeviceScan();
        setTimeout(stopDeviceScan, 2000); // Stop scan after 2 seconds
      };

      if (centralBluetoothState === "poweredOn") {
        continuousScan();
        scanInterval = setInterval(continuousScan, 4000); // Restart scan every 2 seconds
      }

      return () => {
        clearInterval(scanInterval);
        stopDeviceScan();
      };
    }
  }, [centralBluetoothState]);

  const connectToSmartTrainer = async (deviceId) => {
    if (!window.Capacitor) {
      console.log("not capacitor");
      return;
    }
    const FITNESS_MACHINE_UUID = numberToUUID(0x1826);
    const INDOOR_BIKE_DATA_CHARACTERISTIC = numberToUUID(0x2ad2);
    const CYCLING_POWER_MEASUREMENT_CHARACTERISTIC = numberToUUID(0x2a63);

    try {
      await CapacitorBluetooth.connect(deviceId, (deviceId) =>
        onDisconnect(deviceId)
      );
      setDevices((prevDevices) =>
        prevDevices.map((device) =>
          device.id === deviceId ? { ...device, state: "connected" } : device
        )
      );

      try {
        await CapacitorBluetooth.startNotifications(
          deviceId,
          FITNESS_MACHINE_UUID,
          INDOOR_BIKE_DATA_CHARACTERISTIC,
          (value) => {
            let offset = 0;
            let flags;

            console.log("bike value:", value);

            flags = value.getUint16(offset);
            // console.log("flags", flags);
            offset += 2;

            let speed, cadence, power;

            // Check if Instantaneous Speed is present
            if (!(flags & 0x0001)) {
              speed = value.getUint16(offset) * 0.01; // Speed in km/h
              // console.log("speed", speed);
              offset += 2;
            }
            if (flags & 0x0002) {
              // Skip Average Speed
              offset += 2;
            }

            // Check if Instantaneous Cadence is present
            if (flags & 0x0004) {
              cadence = value.getUint16(offset) * 0.5; // Cadence
              // console.log("cadence", cadence);
              offset += 2;
            }

            if (flags & 0x0040) {
              power = value.getUInt16(offset);
              // console.log("power", power);
              offset += 2;
            }

            updateCapacitorSmartTrainerProperties({
              id: deviceId,
              instantaneousCadence: cadence,
            });
            updateCapacitorSmartTrainerProperties({
              id: deviceId,
              instantaneousPower: power,
            });
            updateCapacitorSmartTrainerProperties({
              id: deviceId,
              instantaneousSpeed: speed,
            });
          }
        );
      } catch (error) {
        console.log(
          "Error starting notifications on indoor bike data characteristic:",
          error
        );
      }

      try {
        await CapacitorBluetooth.startNotifications(
          deviceId,
          FITNESS_MACHINE_UUID,
          CYCLING_POWER_MEASUREMENT_CHARACTERISTIC,
          (value) => {
            const flags = value.getUint16(0);

            power = data.getUInt16(2);

            updateCapacitorSmartTrainerProperties({
              id: deviceId,
              instantaneousPower: power,
            });
          }
        );
      } catch (error) {
        console.log(
          "Error starting notifications on cycling power measurement characteristic:",
          error
        );
      }
    } catch (error) {
      console.log("Error connecting to smart trainer:", error);
    }
  };

  useEffect(() => {
    if (router.pathname.includes("devices")) {
      checkBluetoothStatus();

      const intervalId = setInterval(checkBluetoothStatus, 2000);
      return () => clearInterval(intervalId);
    }
  }, [centralBluetoothState]);

  const connectToHeartRateMonitor = async (deviceId) => {
    if (!window.Capacitor) {
      console.log("not capacitor");
      return;
    }
    const HEART_RATE_UUID = numberToUUID(0x180d);
    const HEART_RATE_SERVICE = numberToUUID(0x180d);
    const HEART_RATE_MEASUREMENT_CHARACTERISTIC = numberToUUID(0x2a37);
    const BATTERY_SERVICE = numberToUUID(0x180f);
    const BATTERY_CHARACTERISTIC = numberToUUID(0x2a19);

    try {
      await CapacitorBluetooth.connect(deviceId, (deviceId) =>
        onDisconnect(deviceId)
      );
      setDevices((prevDevices) =>
        prevDevices.map((device) =>
          device.id === deviceId ? { ...device, state: "connected" } : device
        )
      );

      const battery = await CapacitorBluetooth.read(
        deviceId,
        BATTERY_SERVICE,
        BATTERY_CHARACTERISTIC
      );

      updateCapacitorHeartRateMonitorProperties({
        id: deviceId,
        batteryPercentage: battery.getUint8(0),
      });

      await CapacitorBluetooth.startNotifications(
        deviceId,
        HEART_RATE_SERVICE,
        HEART_RATE_MEASUREMENT_CHARACTERISTIC,
        (value) => {
          console.log("hrm value:", value);
          updateCapacitorHeartRateMonitorProperties({
            id: deviceId,
            heartRate: parseHeartRate(value),
          });
        }
      );
    } catch (error) {
      console.log("Error connecting to heart rate monitor:", error);
    }
  };

here are console log statements before/after the notifications stop:
2023-12-23 00:34:51.627493-0500 App[1261:49633] [CoreBluetooth] XPC connection invalid
⚡️ BluetoothLe - Resolve initialize BLE powered on
⚡️ TO JS undefined
⚡️ TO JS {"value":"44 00 00 00 00 00 00 00 "}
⚡️ [log] - bike value: {}
⚡️ To Native -> BluetoothLe initialize 126091190
2023-12-23 00:34:52.607400-0500 App[1261:49633] [CoreBluetooth] XPC connection invalid
⚡️ BluetoothLe - Resolve initialize BLE powered on
⚡️ TO JS undefined
⚡️ To Native -> BluetoothLe removeListener 126091191
⚡️ To Native -> BluetoothLe stopLEScan 126091192
⚡️ BluetoothLe - Stop scanning.
⚡️ TO JS undefined
⚡️ To Native -> BluetoothLe isEnabled 126091193
⚡️ TO JS {"value":true}
⚡️ TO JS {"value":"44 00 00 00 00 00 00 00 "}
⚡️ [log] - bike value: {}
⚡️ To Native -> BluetoothLe initialize 126091194
2023-12-23 00:34:53.633617-0500 App[1261:49633] [CoreBluetooth] XPC connection invalid
⚡️ BluetoothLe - Resolve initialize BLE powered on
⚡️ TO JS undefined
⚡️ TO JS {"value":"44 00 00 00 00 00 00 00 "}
⚡️ [log] - bike value: {}
⚡️ To Native -> BluetoothLe initialize 126091195
2023-12-23 00:34:54.622721-0500 App[1261:49633] [CoreBluetooth] XPC connection invalid
⚡️ BluetoothLe - Resolve initialize BLE powered on
⚡️ TO JS undefined
⚡️ To Native -> BluetoothLe addListener 126091196
⚡️ To Native -> BluetoothLe requestLEScan 126091197
⚡️ BluetoothLe - Resolve startScanning Scan started.
⚡️ TO JS undefined
⚡️ To Native -> BluetoothLe isEnabled 126091198
⚡️ TO JS {"value":true}
⚡️ BluetoothLe - New device found: HRM-Dual:876785
⚡️ TO JS {"rssi":-44,"localName":"HRM-Dual:876785","manufacturerData":{"135":"0c e3 "},"txPower":127,"uuids":["0000180d-0000-1000-8000-00805f9b34fb","6a4e3e10-667b-11e3-949a-0800200c9a66"],"serviceData":{"00003e10-0000-1000-8000-00805f9b34fb":"00 13 00 04 f1 60 0d
⚡️ TO JS {"value":"44 00 00 00 00 00 00 00 "}
⚡️ [log] - bike value: {}
⚡️ To Native -> BluetoothLe initialize 126091199
2023-12-23 00:34:55.612388-0500 App[1261:49876] [CoreBluetooth] XPC connection invalid
⚡️ BluetoothLe - Resolve initialize BLE powered on
⚡️ TO JS undefined
2023-12-23 00:34:56.331343-0500 App[1261:49876] [CoreBluetooth] XPC connection invalid
⚡️ To Native -> BluetoothLe removeListener 126091200
⚡️ To Native -> BluetoothLe stopLEScan 126091201
⚡️ BluetoothLe - Stop scanning.
⚡️ TO JS undefined

---

I am grateful for any help. Thank you.

[pwespi]

Not sure if this is relevant, but I see several initialize calls in the logs. initialize should only be called once.