PWA Web Bluetooth API from page to another

Question

I'm building a PWA using Web Bluetooth API. Connection is OK, I set an eventlistener for getting data and when my Arduino with BLE module HM10 send data, I get them. But my PWA has more than one page. So on first one I have a "Connection" button, and after connection I "listen". When I go to a second page, I use navigator.bluetooth.getDevices() to get previsouly connected device. But I get an empty list.

I though my getDevices() function was bugged but I discoverd a strange thing:

1. my PWA run a browser tab on Chrome. I connect to the device. Then, on another tab I open this url with a Google example (https://googlechrome.github.io/samples/web-bluetooth/get-devices.html) and call Get Bluetooth Devices to get list of connected device, I see my device in this example page.
2. Without closing this second tab, I use my PWA: all page are able to get the device (using navigator.bluetooth.getDevices()), set the even and get data from the Arduino. Great!
3. If I close this tab, connection is lost...

So I think my "connection" is not perfect and when I close my PWA first page, I loose it... But as example avaible on internet are about "one page", I'm a bit lost (like the device connection in fact...).

Here is the code I use:

    function reconnect_ble()
{
  console.log('Search previously connected devices...');
  navigator.bluetooth.getDevices()
  .then(devices => {
    console.log('> Got ' + devices.length + ' Bluetooth devices.');
    
    if (devices.length == 0)
    {
        alert("No module");
        return false;
    }

    var flag_module = false;
    for (const device of devices)
    {
        var nom = device.name;
        // Check if it's our modle
        if (nom == pwa_hm10)
        {
            flag_module = connectToBluetoothDevice(device);
        }
    }

    if (flag_module == false)
    {
        alert("Nothing for us");
        return false;
    }
    else
    {
        return true;
    }
  })
  .catch(error => {
    console.log('Erreur:' + error);
  });
}
//===================================================================================
// First Connection
function connect_ble() 
{
    return (deviceCache ? Promise.resolve(deviceCache) :

        requestBluetoothDevice()).
        then(device => connectToBluetoothDevice(device)).
        catch(error => display_info(error));
}
//-------------------------------------------------------------------------------------
function connectToBluetoothDevice(device)
{
    const abortController = new AbortController();

    // Evenement sur ce device
    device.addEventListener('advertisementreceived', (event) => 
    {
        console.log('connectToBluetoothDevice- Advertisements from "' + device.name + '"...');
        // Stop watching advertisements to conserve battery life.
        abortController.abort();

        // Connexion au serveur GATT
        device.gatt.connect()
        .then(() => 
            {
                console.log('connectToBluetoothDevice - Server GATT from "' + device.name + '"...');
                // Set our event
                connectDeviceAndCacheCharacteristic(device).
                then(characteristic => startNotifications(characteristic)).
                catch(error => display_info(error));
            })
    .catch(error => 
    {
        // Erreur pas de connexion
        console.log(error);
        
    });
    }, { once: true });

    console.log('connectToBluetoothDevice - Watching advertisements from "' + device.name + '"...');
    device.watchAdvertisements({ signal: abortController.signal })
    .catch(error =>
    {
      console.log(error);
    });
}
//----------------------------------------------------------------------------------
// Form to choose device
function requestBluetoothDevice()
{
    return navigator.bluetooth.requestDevice(
    {
        acceptAllDevices: true,
        optionalServices: [0xFFE0]
    }).
    then(device => {
        display_info('Selected: ' + device.name);
        deviceCache = device;        
        deviceCache.addEventListener('gattserverdisconnected',handleDisconnection);
        return deviceCache;
      });
}
//-----------------------------------------------------------------------------------
function connectDeviceAndCacheCharacteristic(device)
{
    if (device.gatt.connected && characteristicCache)
    {
        return Promise.resolve(characteristicCache);
    }

    return device.gatt.connect().
      then(server => {
        return server.getPrimaryService(0xFFE0);
      }).
      then(service => {
        return service.getCharacteristic(0xFFE1);
      }).
      then(characteristic => {
        display_info('characteristic founded');
        characteristicCache = characteristic;

        return characteristicCache;
      });
}
//------------------------------------------------------------------------------------
function startNotifications(characteristic)
{
    return characteristic.startNotifications().
    then(() => {
        characteristic.addEventListener('characteristicvaluechanged',handleCharacteristicValueChanged);
      });
}
//--------------------------------------------------------------------------------------
function handleCharacteristicValueChanged(event)
{
    // Decoding received data
    var decodage = new TextDecoder().decode(event.target.value);
    traitement_data_ble(decodage);
}

Edit

1. If you connect to the bluetooth on Page 1, and go to Page 2 on same tab, connection is lost.
2. If you connect to the bluetooth on Page 1, set an event listenner to get data then open Page 2 on another tab, Page 2 will "see" the bluetooth module, but even if Page 2 set an event listener, this is even from Page 1 that will receive the data.
3. If you connect to the bluetooth on Page 1, don't set event listenner, open Page 2 in other tab and set event listenner on Page 2, Page 2 will receive the data. So case 3 seems to be the only way. Maybe using iFrame for the connection page??

Answer 1

Accessing the same device from multiple pages is not supported and the fact that it seems to partially work is more of a bug than a feature. A device can't effectively distinguish between multiple pages on the same host trying to communicate with it so you need to have a single piece of code which manages the connection to the device.

The correct way to do this today is to create a single-page application so that the connection held by that page can remain own even if the user navigates to different "pages" of your application. If you need to create separate windows these can communicate with the device by sending commands back through the single page that owns the connection using postMessage or Broadcast Channel.

The ideal solution, which is not currently supported, is to use a Shared Worker for this. Shared Workers are a type of web worker which is owned by all the currently open pages of your app at once. It can thus hold shared state (such as the Bluetooth connection) in behalf of your application and won't exit unless every window of your app is closed.