request MTU weird behaviour about react-native-ble-manager HOT 7 OPEN

Weird, i see you're using version ^11.3.2 which can be any version newer than that, can you make sure to install version react-native-ble-manager version: "11.5.2" and do a ./android/gradlew clean for a full library refresh and check if the issue is still happening?

from react-native-ble-manager.

Done, same results.
However, I read a bit of logs and code (even if I did not completely understand it) and I tried this:

        if (this.discoveredDevicesIDs.size === 0) {
            throw new Error('No devices discovered');
        }
        const deviceID = Array.from(this.discoveredDevicesIDs)[0];
        await BleManager.connect(deviceID);
        console.log('Connected to', deviceID);
        await new Promise(resolve => setTimeout(resolve, 2000));
        await BleManager.requestMTU(deviceID, 232);
        console.log('MTU requested');
        Alert.alert('MTU requested');

and it works like a charm.
It looks like there is some problem with the "command" management or something similar.
This workaround made me think that maybe it's not about the version but about the "speed" of the tablet.
The Android 14 tablet is 2024, while the Android 13 is much older.

from react-native-ble-manager.

Issue Description:

When I run my app on devices with Android 13 or lower, I receive the full data from my Bluetooth device. However, when running the same app on an Android 14 device, the data received from the Bluetooth device is truncated. Despite seeing "MTU size changed to 517 bytes" in the logs on both Android 13 and Android 14, the issue persists only on Android 14. I'm using "react-native-ble-manager": "^11.5.3". Please provide a solution urgently.

Code Example:

import BleManager from 'react-native-ble-manager';
import { Alert } from 'react-native';

const connectPeripheral = async (peripheral, connect, save) => {
try {
let ShowAlert = false;

if (peripheral) {
  if (connect) {
    console.log('Peripheral exists in the list.');
  } else {
    console.log('Peripheral does not exist in the list.');
    addOrUpdatePeripheral(peripheral.id, { ...peripheral, connecting: true });
  }

  console.log('Before connecting to peripheral...');

  // Create a promise for the connection
  const connectPromise = BleManager.connect(peripheral.id);

  // Create a timeout promise
  const timeoutPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
      reject(new Error('Connection timeout'));
    }, 20000); // Adjust the timeout duration as needed
  });

  // Use Promise.race to wait for the first promise that resolves
  try {
    await Promise.race([connectPromise, timeoutPromise]);
    console.debug(`[connectPeripheral][${peripheral.id}] connected.`);

    console.log('After connecting to peripheral...');

    if (connect) {
      console.log('Peripheral exists in the list.');
    } else {
      console.log('Peripheral does not exist in the list.');
      addOrUpdatePeripheral(peripheral.id, { 
        ...peripheral, 
        connecting: false, 
        connected: true 
      });
    }

    // Allow some time for bonding and connection to finish
    await new Promise(resolve => setTimeout(resolve, 2000));

    try {
      const mtu = await BleManager.requestMTU(peripheral.id, 185);
      console.log(`MTU size changed to ${mtu} bytes`);
    } catch (error) {
      console.error(`Failed to change MTU size: ${error}`);
    }

    // Retrieve services
    const peripheralData = await BleManager.retrieveServices(peripheral.id);
    console.debug(`[connectPeripheral][${peripheral.id}] retrieved peripheral services`, JSON.stringify(peripheralData));

    storeUniqueObject('userData', peripheral, false);

    if (!movefrwd) {
      setisLoading(false);
      ShowAlert = true;
      navigation.navigate('BTStatusScreen', {
        peripheralObj: peripheral,
        BleManagerObj: BleManager
      });
      console.log(`ShowAlert: ${ShowAlert}`);
    }
  } catch (error) {
    setisLoading(false);
    await BleManager.disconnect(peripheral.id);
    if (error.message === 'Connection timeout') {
      console.log('Connection to peripheral timed out. Device may be off or not in discovery mode.');
    } else {
      console.error(`Error connecting to peripheral: ${error}`);
      if (!movefrwd) {
        // Handle other connection errors here
      }
    }
  }
}

} catch (error) {
console.error([connectPeripheral][${peripheral.id}] connectPeripheral error, error);
}
};

from react-native-ble-manager.

@akiannillo There is some performance issue in this module. It cannot work as expected. I think you should create your own module. I am stuck at a point too. Where nrf connect app performs well and is able to receive data in 100ms. Whereas, in this module, it sends disconnects. This module total **** me up.

from react-native-ble-manager.

Issue Description:

When I run my app on devices with Android 13 or lower, I receive the full data from my Bluetooth device. However, when running the same app on an Android 14 device, the data received from the Bluetooth device is truncated. Despite seeing "MTU size changed to 517 bytes" in the logs on both Android 13 and Android 14, the issue persists only on Android 14. I'm using "react-native-ble-manager": "^11.5.3". Please provide a solution urgently.

Code Example:

import BleManager from 'react-native-ble-manager'; import { Alert } from 'react-native';

const connectPeripheral = async (peripheral, connect, save) => { try { let ShowAlert = false;

if (peripheral) {
  if (connect) {
    console.log('Peripheral exists in the list.');
  } else {
    console.log('Peripheral does not exist in the list.');
    addOrUpdatePeripheral(peripheral.id, { ...peripheral, connecting: true });
  }

  console.log('Before connecting to peripheral...');

  // Create a promise for the connection
  const connectPromise = BleManager.connect(peripheral.id);

  // Create a timeout promise
  const timeoutPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
      reject(new Error('Connection timeout'));
    }, 20000); // Adjust the timeout duration as needed
  });

  // Use Promise.race to wait for the first promise that resolves
  try {
    await Promise.race([connectPromise, timeoutPromise]);
    console.debug(`[connectPeripheral][${peripheral.id}] connected.`);

    console.log('After connecting to peripheral...');

    if (connect) {
      console.log('Peripheral exists in the list.');
    } else {
      console.log('Peripheral does not exist in the list.');
      addOrUpdatePeripheral(peripheral.id, { 
        ...peripheral, 
        connecting: false, 
        connected: true 
      });
    }

    // Allow some time for bonding and connection to finish
    await new Promise(resolve => setTimeout(resolve, 2000));

    try {
      const mtu = await BleManager.requestMTU(peripheral.id, 185);
      console.log(`MTU size changed to ${mtu} bytes`);
    } catch (error) {
      console.error(`Failed to change MTU size: ${error}`);
    }

    // Retrieve services
    const peripheralData = await BleManager.retrieveServices(peripheral.id);
    console.debug(`[connectPeripheral][${peripheral.id}] retrieved peripheral services`, JSON.stringify(peripheralData));

    storeUniqueObject('userData', peripheral, false);

    if (!movefrwd) {
      setisLoading(false);
      ShowAlert = true;
      navigation.navigate('BTStatusScreen', {
        peripheralObj: peripheral,
        BleManagerObj: BleManager
      });
      console.log(`ShowAlert: ${ShowAlert}`);
    }
  } catch (error) {
    setisLoading(false);
    await BleManager.disconnect(peripheral.id);
    if (error.message === 'Connection timeout') {
      console.log('Connection to peripheral timed out. Device may be off or not in discovery mode.');
    } else {
      console.error(`Error connecting to peripheral: ${error}`);
      if (!movefrwd) {
        // Handle other connection errors here
      }
    }
  }
}

} catch (error) { console.error([connectPeripheral][${peripheral.id}] connectPeripheral error, error); } };

Thats a behavior that changed on Android Bluetooth since 14.

Issue Description:

When I run my app on devices with Android 13 or lower, I receive the full data from my Bluetooth device. However, when running the same app on an Android 14 device, the data received from the Bluetooth device is truncated. Despite seeing "MTU size changed to 517 bytes" in the logs on both Android 13 and Android 14, the issue persists only on Android 14. I'm using "react-native-ble-manager": "^11.5.3". Please provide a solution urgently.

Code Example:

import BleManager from 'react-native-ble-manager'; import { Alert } from 'react-native';

const connectPeripheral = async (peripheral, connect, save) => { try { let ShowAlert = false;

if (peripheral) {
  if (connect) {
    console.log('Peripheral exists in the list.');
  } else {
    console.log('Peripheral does not exist in the list.');
    addOrUpdatePeripheral(peripheral.id, { ...peripheral, connecting: true });
  }

  console.log('Before connecting to peripheral...');

  // Create a promise for the connection
  const connectPromise = BleManager.connect(peripheral.id);

  // Create a timeout promise
  const timeoutPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
      reject(new Error('Connection timeout'));
    }, 20000); // Adjust the timeout duration as needed
  });

  // Use Promise.race to wait for the first promise that resolves
  try {
    await Promise.race([connectPromise, timeoutPromise]);
    console.debug(`[connectPeripheral][${peripheral.id}] connected.`);

    console.log('After connecting to peripheral...');

    if (connect) {
      console.log('Peripheral exists in the list.');
    } else {
      console.log('Peripheral does not exist in the list.');
      addOrUpdatePeripheral(peripheral.id, { 
        ...peripheral, 
        connecting: false, 
        connected: true 
      });
    }

    // Allow some time for bonding and connection to finish
    await new Promise(resolve => setTimeout(resolve, 2000));

    try {
      const mtu = await BleManager.requestMTU(peripheral.id, 185);
      console.log(`MTU size changed to ${mtu} bytes`);
    } catch (error) {
      console.error(`Failed to change MTU size: ${error}`);
    }

    // Retrieve services
    const peripheralData = await BleManager.retrieveServices(peripheral.id);
    console.debug(`[connectPeripheral][${peripheral.id}] retrieved peripheral services`, JSON.stringify(peripheralData));

    storeUniqueObject('userData', peripheral, false);

    if (!movefrwd) {
      setisLoading(false);
      ShowAlert = true;
      navigation.navigate('BTStatusScreen', {
        peripheralObj: peripheral,
        BleManagerObj: BleManager
      });
      console.log(`ShowAlert: ${ShowAlert}`);
    }
  } catch (error) {
    setisLoading(false);
    await BleManager.disconnect(peripheral.id);
    if (error.message === 'Connection timeout') {
      console.log('Connection to peripheral timed out. Device may be off or not in discovery mode.');
    } else {
      console.error(`Error connecting to peripheral: ${error}`);
      if (!movefrwd) {
        // Handle other connection errors here
      }
    }
  }
}

} catch (error) { console.error([connectPeripheral][${peripheral.id}] connectPeripheral error, error); } };

Thats a behavior change in the bluetooth not in the library itself, take a look on https://developer.android.com/about/versions/14/behavior-changes-all for further details.

Something that i had to fix in order to work with Android 14 devices.
Before 14:
connect -> discover -> listen for characteristics changes.
After 14:
connect -> discover -> requestMtu(thats the minimum MTU to negotiate with device, probably the highest mtu size will be given to you) -> listen for characteristics changes.

from react-native-ble-manager.

@rahulp9538 that fixes your MTU negotiation size.

from react-native-ble-manager.

Please provide a solution urgently

Can you provide a minimal repro that shows this perfomance issue?

from react-native-ble-manager.