tirecheck-device-sdk 0.1.94 → 0.1.95

package/dist/index.cjs

@@ -502,7 +502,7 @@ const deviceMeta = {
     getDeviceInfoFromAdvertising: bridgeOtaAdvertisingParser.getDeviceInfoFromAdvertising
   },
   flexiGaugeTpms: {
-    nameRegex: /Flexi.*/,
+    nameRegex: /^Flexi.*/,
     communication: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
@@ -565,7 +565,7 @@ const bluetooth = {
   stopScan() {
     ble.stopScan();
   },
-  connect,
+  connect: connect$1,
   disconnect: disconnect$1,
   write,
   read
@@ -592,7 +592,7 @@ async function scanDevices(services = [], duration) {
     (e) => console.error("ble.startScanWithOptions error:", e)
   );
 }
-async function connect(deviceId, disconnectCallback) {
+async function connect$1(deviceId, disconnectCallback) {
   if (toolsSvc.canCommunicateWith(deviceId)) return console.warn("Connect Warn: Already connected to device");
   store.setState(deviceId, "connecting");
   let connectedDevice;
@@ -713,6 +713,78 @@ function getDeviceNameFromAdvertising(advertising) {
   return deviceName;
 }
 
+const otaServiceUuid = "1d14d6ee-fd63-4fa1-bfa4-8f47b42119f0";
+const otaControlCharacteristicUuid = "f7bf3564-fb6d-4e53-88a4-5e37e0326063";
+const otaDataCharacteristicUuid = "984227f3-34fc-4045-a5d0-2c581f81a153";
+const bridgeOtaCommands = {
+  async beginOta(deviceId) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([0]).buffer, true);
+  },
+  async uploadOtaChunk(deviceId, data) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data, true);
+  },
+  async endOta(deviceId) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer, true);
+  }
+};
+
+const bridgeOtaService = {
+  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
+    await delay(2e3);
+    progressCallback("Connecting to the bridge...", 0.1);
+    await bridgeOta.connect(deviceId);
+    progressCallback("Uploading bootloader...", 0.12);
+    await bridgeOtaCommands.beginOta(deviceId);
+    await uploadOta(deviceId, bootloader, (str, percents) => progressCallback(str, 0.12 + percents * 0.2));
+    await bridgeOtaCommands.endOta(deviceId);
+    progressCallback("Uploading application...", 0.32);
+    await bridgeOtaCommands.beginOta(deviceId);
+    await uploadOta(deviceId, firmware, (str, percents) => progressCallback(str, 0.32 + percents * 0.5));
+    await bridgeOtaCommands.endOta(deviceId);
+    progressCallback("Upload completed, disconnecting...", 0.81);
+    await bridgeOta.disconnect(deviceId);
+    progressCallback("Disconnected...", 1);
+  }
+};
+async function uploadOta(deviceId, firmwareBinary, reportStatus) {
+  let uploadedBytes = 0;
+  let chunkIndex = 0;
+  const mtu = store.platform === "android" ? 512 : deviceMeta.bridgeOta.mtu;
+  while (uploadedBytes < firmwareBinary.byteLength) {
+    if (chunkIndex % 100 === 0)
+      reportStatus(
+        `Uploading new firmware... (${___default.round(uploadedBytes / 1e3)} / ${___default.round(
+          firmwareBinary.byteLength / 1e3
+        )} KB)`,
+        uploadedBytes / firmwareBinary.byteLength
+      );
+    const chunkSize = Math.min(mtu - 3, firmwareBinary.byteLength - uploadedBytes);
+    const chunk = firmwareBinary.slice(uploadedBytes, uploadedBytes + chunkSize);
+    await bridgeOtaCommands.uploadOtaChunk(deviceId, chunk);
+    uploadedBytes += chunkSize;
+    chunkIndex++;
+  }
+}
+
+const bridgeOta = {
+  async connect(deviceId) {
+    await bluetooth.connect(deviceId, this.disconnect);
+    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+    if (store.platform !== "ios") {
+      await ble.requestMtu(_deviceId, 512);
+    }
+    store.setState(deviceId, "paired");
+  },
+  async disconnect(deviceId, reason) {
+    store.setState(deviceId, "disconnecting");
+    await bluetooth.disconnect(deviceId);
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
+  },
+  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
+    return bridgeOtaService.updateFirmware(deviceId, bootloader, firmware, progressCallback);
+  }
+};
+
 const bridgeCommandStructures = {
   workshopCanSettings: {
     id: [98, 96],
@@ -1530,25 +1602,26 @@ const bridgeSecurity = {
 };
 
 const bridgeMeta = deviceMeta.bridge;
-let promiseQueue = Promise.resolve();
-let currentResolve = (_v) => {
-};
-let currentReject = (_v) => {
-};
-let responseIdentifier;
-const promiseQueue$1 = {
-  clearQueue(message) {
-    currentReject(new Error(message ?? "Stopped sending commands"));
-    promiseQueue = Promise.resolve();
-    responseIdentifier = [];
+const devicePromiseQueue = {};
+const deviceCurrentResolve = {};
+const deviceCurrentReject = {};
+const deviceResponseIdentifier = {};
+const promiseQueue = {
+  clearQueue(deviceId, message) {
+    if (deviceCurrentReject[deviceId]) {
+      deviceCurrentReject[deviceId](new Error(message ?? "Stopped sending commands"));
+    }
+    devicePromiseQueue[deviceId] = Promise.resolve();
+    deviceResponseIdentifier[deviceId] = [];
   },
   async enqueue(device, payload) {
-    promiseQueue = promiseQueue.then(() => {
+    if (devicePromiseQueue[device.id] === void 0) devicePromiseQueue[device.id] = Promise.resolve();
+    devicePromiseQueue[device.id] = devicePromiseQueue[device.id].then(() => {
       const promise = new Promise((resolve, reject) => {
-        currentResolve = resolve;
-        currentReject = reject;
+        deviceCurrentResolve[device.id] = resolve;
+        deviceCurrentReject[device.id] = reject;
         const isKeepAlive = payload[3] === commandIds.keepAlive;
-        responseIdentifier = [isKeepAlive ? 126 : 0, payload[4]];
+        deviceResponseIdentifier[device.id] = [isKeepAlive ? 126 : 0, payload[4]];
         const signedData = bridgeSecurity.getSignedCommand(device, payload);
         if (!toolsSvc.canCommunicateWith(device.id)) return reject(new Error("Bridge not connected"));
         if (signedData.length > 110) {
@@ -1574,21 +1647,21 @@ const promiseQueue$1 = {
           );
         }
       });
-      return withTimeout(promise, 5e3, `Command timed out ${responseIdentifier}`);
+      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier[device.id]}, ${device.id}`);
     });
-    return promiseQueue;
+    return devicePromiseQueue[device.id];
   },
   async processMessage(deviceId, payload) {
     const numberArray = Array.from(new Uint8Array(payload));
     if (numberArray[3] === 127) {
       console.error(numberArray);
-      return currentReject(new Error(`Command not succesful: ${numberArray[4]}`));
+      return deviceCurrentReject[deviceId](new Error(`Command not succesful: ${numberArray[4]}`));
     }
     if ([226, 81].includes(numberArray[3]) && numberArray[4] && toolsSvc.canCommunicateWith(deviceId)) {
       store.bridgeRebootRequired[deviceId] = true;
     }
-    if ((!responseIdentifier[0] || numberArray[3] === responseIdentifier[0]) && (!responseIdentifier[1] || numberArray[4] === responseIdentifier[1])) {
-      return currentResolve(numberArray);
+    if ((!deviceResponseIdentifier[deviceId][0] || numberArray[3] === deviceResponseIdentifier[deviceId][0]) && (!deviceResponseIdentifier[deviceId][1] || numberArray[4] === deviceResponseIdentifier[deviceId][1])) {
+      return deviceCurrentResolve[deviceId](numberArray);
     }
     console.warn("message from the device not belonging to the pending promise: ", numberArray);
   }
@@ -1975,79 +2048,7 @@ const bridgeCommands = {
       }
       this.sendKeepAliveCommand(device);
     }, 1e4);
-    return promiseQueue$1.enqueue(device, writeCommand);
-  }
-};
-
-const otaServiceUuid = "1d14d6ee-fd63-4fa1-bfa4-8f47b42119f0";
-const otaControlCharacteristicUuid = "f7bf3564-fb6d-4e53-88a4-5e37e0326063";
-const otaDataCharacteristicUuid = "984227f3-34fc-4045-a5d0-2c581f81a153";
-const bridgeOtaCommands = {
-  async beginOta(deviceId) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([0]).buffer, true);
-  },
-  async uploadOtaChunk(deviceId, data) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data, true);
-  },
-  async endOta(deviceId) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer, true);
-  }
-};
-
-const bridgeOtaService = {
-  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
-    await delay(2e3);
-    progressCallback("Connecting to the bridge...", 0.1);
-    await bridgeOta.connect(deviceId);
-    progressCallback("Uploading bootloader...", 0.12);
-    await bridgeOtaCommands.beginOta(deviceId);
-    await uploadOta(deviceId, bootloader, (str, percents) => progressCallback(str, 0.12 + percents * 0.2));
-    await bridgeOtaCommands.endOta(deviceId);
-    progressCallback("Uploading application...", 0.32);
-    await bridgeOtaCommands.beginOta(deviceId);
-    await uploadOta(deviceId, firmware, (str, percents) => progressCallback(str, 0.32 + percents * 0.5));
-    await bridgeOtaCommands.endOta(deviceId);
-    progressCallback("Upload completed, disconnecting...", 0.81);
-    await bridgeOta.disconnect(deviceId);
-    progressCallback("Disconnected...", 1);
-  }
-};
-async function uploadOta(deviceId, firmwareBinary, reportStatus) {
-  let uploadedBytes = 0;
-  let chunkIndex = 0;
-  const mtu = store.platform === "android" ? 512 : deviceMeta.bridgeOta.mtu;
-  while (uploadedBytes < firmwareBinary.byteLength) {
-    if (chunkIndex % 100 === 0)
-      reportStatus(
-        `Uploading new firmware... (${___default.round(uploadedBytes / 1e3)} / ${___default.round(
-          firmwareBinary.byteLength / 1e3
-        )} KB)`,
-        uploadedBytes / firmwareBinary.byteLength
-      );
-    const chunkSize = Math.min(mtu - 3, firmwareBinary.byteLength - uploadedBytes);
-    const chunk = firmwareBinary.slice(uploadedBytes, uploadedBytes + chunkSize);
-    await bridgeOtaCommands.uploadOtaChunk(deviceId, chunk);
-    uploadedBytes += chunkSize;
-    chunkIndex++;
-  }
-}
-
-const bridgeOta = {
-  async connect(deviceId) {
-    await bluetooth.connect(deviceId, this.disconnect);
-    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
-    if (store.platform !== "ios") {
-      await ble.requestMtu(_deviceId, 512);
-    }
-    store.setState(deviceId, "paired");
-  },
-  async disconnect(deviceId, reason) {
-    store.setState(deviceId, "disconnecting");
-    await bluetooth.disconnect(deviceId);
-    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
-  },
-  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
-    return bridgeOtaService.updateFirmware(deviceId, bootloader, firmware, progressCallback);
+    return promiseQueue.enqueue(device, writeCommand);
   }
 };
 
@@ -2069,8 +2070,13 @@ const bridgeService = {
   getVehicleReadings,
   resetAutolearnStatuses,
   getAutolearnStatuses,
-  isRebootRequired
+  isRebootRequired,
+  sendPinCommand
 };
+async function sendPinCommand(deviceId) {
+  if (!canCommunicateWith(deviceId)) throw new Error("Bridge not connected");
+  await bridgeCommands.sendPinCommand(deviceId);
+}
 async function updateFirmware(deviceId, bootloader, firmware, reportStatus) {
   reportStatus("Sending OTA Request...", 0.02);
   await bridgeCommands.sendOtaRequest(deviceId);
@@ -2392,7 +2398,7 @@ async function getVehicleReadings(deviceId, tcVehicle) {
   try {
     for (const vehicleTyre of tcVehicle.tcTyres) {
       if (vehicleTyre.tcTpmsSensor && vehicleTyre.mountedOn?.positionId) {
-        if (!canCommunicateWith(deviceId)) throw new Error("getVehicleReadings: no connected bridge");
+        if (!canCommunicateWith(deviceId)) break;
         const reading = await getSensorReading(deviceId, vehicleTyre.mountedOn.positionId);
         readings.push(reading);
       }
@@ -2690,12 +2696,28 @@ function isRebootRequired(deviceId) {
 
 const bridge = {
   disconnect,
-  async connect(deviceId, accessLevel) {
-    if (canCommunicateWith(deviceId)) return;
-    await promiseQueue$1.clearQueue("Previous pending commands aborted");
-    const bridgeMeta = deviceMeta.bridge;
-    await bluetooth.connect(deviceId, disconnect);
-    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+  connect,
+  getVehicle: bridgeService.getVehicle,
+  setVehicle: bridgeService.setVehicle,
+  getConfiguration: bridgeService.getConfiguration,
+  setConfiguration: bridgeService.setConfiguration,
+  getSensorReading: bridgeService.getSensorReading,
+  getVehicleReadings: bridgeService.getVehicleReadings,
+  getAutolearnStatuses: bridgeService.getAutolearnStatuses,
+  resetAutolearnStatuses: bridgeService.resetAutolearnStatuses,
+  updateFirmware: bridgeService.updateFirmware,
+  isRebootRequired: bridgeService.isRebootRequired
+};
+async function connect(deviceId, accessLevel) {
+  if (canCommunicateWith(deviceId)) return;
+  await promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
+  const bridgeMeta = deviceMeta.bridge;
+  await bluetooth.connect(deviceId, disconnect);
+  if (store.deviceState[deviceId] === "paired") {
+    return console.warn("Connect Warn: Already connected");
+  }
+  const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+  try {
     if (store.platform !== "ios") {
       await ble.requestMtu(_deviceId, deviceMeta.bridge.mtu);
     }
@@ -2703,28 +2725,22 @@ const bridge = {
       _deviceId,
       bridgeMeta.communication.serviceId,
       bridgeMeta.communication.characteristicId,
-      (notification) => promiseQueue$1.processMessage(deviceId, notification),
+      (notification) => promiseQueue.processMessage(deviceId, notification),
       (error) => console.error("startNotification Error", error)
     );
     store.deviceAccessLevel[deviceId] = accessLevel ?? "driver";
     store.bridgeRebootRequired[deviceId] = false;
-    await bridgeCommands.sendPinCommand(deviceId);
+    await bridgeService.sendPinCommand(deviceId);
     store.setState(deviceId, "paired");
-  },
-  getVehicle: bridgeService.getVehicle,
-  setVehicle: bridgeService.setVehicle,
-  getConfiguration: bridgeService.getConfiguration,
-  setConfiguration: bridgeService.setConfiguration,
-  getSensorReading: bridgeService.getSensorReading,
-  getVehicleReadings: bridgeService.getVehicleReadings,
-  getAutolearnStatuses: bridgeService.getAutolearnStatuses,
-  resetAutolearnStatuses: bridgeService.resetAutolearnStatuses,
-  updateFirmware: bridgeService.updateFirmware,
-  isRebootRequired: bridgeService.isRebootRequired
-};
+  } catch (e) {
+    disconnect(deviceId);
+    throw new Error(`Pairing unsuccessful ${e}`);
+  }
+}
 async function disconnect(deviceId, reason) {
+  await waitUntil(() => store.deviceState[deviceId] === "paired" || store.deviceState[deviceId] === void 0);
   store.setState(deviceId, "disconnecting");
-  promiseQueue$1.clearQueue("Previous pending commands aborted");
+  promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
   await bluetooth.disconnect(deviceId);
   delete store.devices[deviceId];
   deviceUnreachableCallback?.(deviceId);

package/dist/index.d.cts

@@ -809,7 +809,7 @@ type Wrapper<T extends Record<string, (...args: any) => any>> = {
 };
 type ReportStatusFn = (status: string, completionPercentage: number) => void;
 type DeviceState = 'connected' | 'connecting' | 'disconnecting' | 'paired' | undefined;
-type StateReason = 'lostConnection' | 'manualDisconnection' | 'failedConnection' | 'failedDisconnection' | 'firmwareUpdate';
+type StateReason = 'lostConnection' | 'manualDisconnection' | 'failedConnection' | 'failedDisconnection' | 'firmwareUpdate' | string;
 interface EventHandlers {
     'fg:treadDepth'?: (deviceId: string, value: number) => void;
     'fg:button'?: (deviceId: string, value: string) => void;
@@ -836,7 +836,7 @@ declare function createTirecheckDeviceSdk(platform: DevicePlatform, bleImplement
     /** Methods for working with Tirecheck CAN Bridge */
     bridge: {
         disconnect: (deviceId: string, reason?: StateReason) => Promise<void>;
-        connect(deviceId: string, accessLevel: BridgeAccessLevel): Promise<void>;
+        connect: (deviceId: string, accessLevel: BridgeAccessLevel) => Promise<void>;
         getVehicle: (deviceId: string) => Promise<BridgeTcVehicle>;
         setVehicle: (deviceId: string, tcVehicle: BridgeTcVehicle) => Promise<void>;
         getConfiguration: (deviceId: string) => Promise<BridgeConfiguration>;

package/dist/index.d.mts

@@ -809,7 +809,7 @@ type Wrapper<T extends Record<string, (...args: any) => any>> = {
 };
 type ReportStatusFn = (status: string, completionPercentage: number) => void;
 type DeviceState = 'connected' | 'connecting' | 'disconnecting' | 'paired' | undefined;
-type StateReason = 'lostConnection' | 'manualDisconnection' | 'failedConnection' | 'failedDisconnection' | 'firmwareUpdate';
+type StateReason = 'lostConnection' | 'manualDisconnection' | 'failedConnection' | 'failedDisconnection' | 'firmwareUpdate' | string;
 interface EventHandlers {
     'fg:treadDepth'?: (deviceId: string, value: number) => void;
     'fg:button'?: (deviceId: string, value: string) => void;
@@ -836,7 +836,7 @@ declare function createTirecheckDeviceSdk(platform: DevicePlatform, bleImplement
     /** Methods for working with Tirecheck CAN Bridge */
     bridge: {
         disconnect: (deviceId: string, reason?: StateReason) => Promise<void>;
-        connect(deviceId: string, accessLevel: BridgeAccessLevel): Promise<void>;
+        connect: (deviceId: string, accessLevel: BridgeAccessLevel) => Promise<void>;
         getVehicle: (deviceId: string) => Promise<BridgeTcVehicle>;
         setVehicle: (deviceId: string, tcVehicle: BridgeTcVehicle) => Promise<void>;
         getConfiguration: (deviceId: string) => Promise<BridgeConfiguration>;

package/dist/index.d.ts

@@ -809,7 +809,7 @@ type Wrapper<T extends Record<string, (...args: any) => any>> = {
 };
 type ReportStatusFn = (status: string, completionPercentage: number) => void;
 type DeviceState = 'connected' | 'connecting' | 'disconnecting' | 'paired' | undefined;
-type StateReason = 'lostConnection' | 'manualDisconnection' | 'failedConnection' | 'failedDisconnection' | 'firmwareUpdate';
+type StateReason = 'lostConnection' | 'manualDisconnection' | 'failedConnection' | 'failedDisconnection' | 'firmwareUpdate' | string;
 interface EventHandlers {
     'fg:treadDepth'?: (deviceId: string, value: number) => void;
     'fg:button'?: (deviceId: string, value: string) => void;
@@ -836,7 +836,7 @@ declare function createTirecheckDeviceSdk(platform: DevicePlatform, bleImplement
     /** Methods for working with Tirecheck CAN Bridge */
     bridge: {
         disconnect: (deviceId: string, reason?: StateReason) => Promise<void>;
-        connect(deviceId: string, accessLevel: BridgeAccessLevel): Promise<void>;
+        connect: (deviceId: string, accessLevel: BridgeAccessLevel) => Promise<void>;
         getVehicle: (deviceId: string) => Promise<BridgeTcVehicle>;
         setVehicle: (deviceId: string, tcVehicle: BridgeTcVehicle) => Promise<void>;
         getConfiguration: (deviceId: string) => Promise<BridgeConfiguration>;

package/dist/index.mjs

@@ -495,7 +495,7 @@ const deviceMeta = {
     getDeviceInfoFromAdvertising: bridgeOtaAdvertisingParser.getDeviceInfoFromAdvertising
   },
   flexiGaugeTpms: {
-    nameRegex: /Flexi.*/,
+    nameRegex: /^Flexi.*/,
     communication: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
@@ -558,7 +558,7 @@ const bluetooth = {
   stopScan() {
     ble.stopScan();
   },
-  connect,
+  connect: connect$1,
   disconnect: disconnect$1,
   write,
   read
@@ -585,7 +585,7 @@ async function scanDevices(services = [], duration) {
     (e) => console.error("ble.startScanWithOptions error:", e)
   );
 }
-async function connect(deviceId, disconnectCallback) {
+async function connect$1(deviceId, disconnectCallback) {
   if (toolsSvc.canCommunicateWith(deviceId)) return console.warn("Connect Warn: Already connected to device");
   store.setState(deviceId, "connecting");
   let connectedDevice;
@@ -706,6 +706,78 @@ function getDeviceNameFromAdvertising(advertising) {
   return deviceName;
 }
 
+const otaServiceUuid = "1d14d6ee-fd63-4fa1-bfa4-8f47b42119f0";
+const otaControlCharacteristicUuid = "f7bf3564-fb6d-4e53-88a4-5e37e0326063";
+const otaDataCharacteristicUuid = "984227f3-34fc-4045-a5d0-2c581f81a153";
+const bridgeOtaCommands = {
+  async beginOta(deviceId) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([0]).buffer, true);
+  },
+  async uploadOtaChunk(deviceId, data) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data, true);
+  },
+  async endOta(deviceId) {
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer, true);
+  }
+};
+
+const bridgeOtaService = {
+  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
+    await delay(2e3);
+    progressCallback("Connecting to the bridge...", 0.1);
+    await bridgeOta.connect(deviceId);
+    progressCallback("Uploading bootloader...", 0.12);
+    await bridgeOtaCommands.beginOta(deviceId);
+    await uploadOta(deviceId, bootloader, (str, percents) => progressCallback(str, 0.12 + percents * 0.2));
+    await bridgeOtaCommands.endOta(deviceId);
+    progressCallback("Uploading application...", 0.32);
+    await bridgeOtaCommands.beginOta(deviceId);
+    await uploadOta(deviceId, firmware, (str, percents) => progressCallback(str, 0.32 + percents * 0.5));
+    await bridgeOtaCommands.endOta(deviceId);
+    progressCallback("Upload completed, disconnecting...", 0.81);
+    await bridgeOta.disconnect(deviceId);
+    progressCallback("Disconnected...", 1);
+  }
+};
+async function uploadOta(deviceId, firmwareBinary, reportStatus) {
+  let uploadedBytes = 0;
+  let chunkIndex = 0;
+  const mtu = store.platform === "android" ? 512 : deviceMeta.bridgeOta.mtu;
+  while (uploadedBytes < firmwareBinary.byteLength) {
+    if (chunkIndex % 100 === 0)
+      reportStatus(
+        `Uploading new firmware... (${_.round(uploadedBytes / 1e3)} / ${_.round(
+          firmwareBinary.byteLength / 1e3
+        )} KB)`,
+        uploadedBytes / firmwareBinary.byteLength
+      );
+    const chunkSize = Math.min(mtu - 3, firmwareBinary.byteLength - uploadedBytes);
+    const chunk = firmwareBinary.slice(uploadedBytes, uploadedBytes + chunkSize);
+    await bridgeOtaCommands.uploadOtaChunk(deviceId, chunk);
+    uploadedBytes += chunkSize;
+    chunkIndex++;
+  }
+}
+
+const bridgeOta = {
+  async connect(deviceId) {
+    await bluetooth.connect(deviceId, this.disconnect);
+    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+    if (store.platform !== "ios") {
+      await ble.requestMtu(_deviceId, 512);
+    }
+    store.setState(deviceId, "paired");
+  },
+  async disconnect(deviceId, reason) {
+    store.setState(deviceId, "disconnecting");
+    await bluetooth.disconnect(deviceId);
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
+  },
+  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
+    return bridgeOtaService.updateFirmware(deviceId, bootloader, firmware, progressCallback);
+  }
+};
+
 const bridgeCommandStructures = {
   workshopCanSettings: {
     id: [98, 96],
@@ -1523,25 +1595,26 @@ const bridgeSecurity = {
 };
 
 const bridgeMeta = deviceMeta.bridge;
-let promiseQueue = Promise.resolve();
-let currentResolve = (_v) => {
-};
-let currentReject = (_v) => {
-};
-let responseIdentifier;
-const promiseQueue$1 = {
-  clearQueue(message) {
-    currentReject(new Error(message ?? "Stopped sending commands"));
-    promiseQueue = Promise.resolve();
-    responseIdentifier = [];
+const devicePromiseQueue = {};
+const deviceCurrentResolve = {};
+const deviceCurrentReject = {};
+const deviceResponseIdentifier = {};
+const promiseQueue = {
+  clearQueue(deviceId, message) {
+    if (deviceCurrentReject[deviceId]) {
+      deviceCurrentReject[deviceId](new Error(message ?? "Stopped sending commands"));
+    }
+    devicePromiseQueue[deviceId] = Promise.resolve();
+    deviceResponseIdentifier[deviceId] = [];
   },
   async enqueue(device, payload) {
-    promiseQueue = promiseQueue.then(() => {
+    if (devicePromiseQueue[device.id] === void 0) devicePromiseQueue[device.id] = Promise.resolve();
+    devicePromiseQueue[device.id] = devicePromiseQueue[device.id].then(() => {
       const promise = new Promise((resolve, reject) => {
-        currentResolve = resolve;
-        currentReject = reject;
+        deviceCurrentResolve[device.id] = resolve;
+        deviceCurrentReject[device.id] = reject;
         const isKeepAlive = payload[3] === commandIds.keepAlive;
-        responseIdentifier = [isKeepAlive ? 126 : 0, payload[4]];
+        deviceResponseIdentifier[device.id] = [isKeepAlive ? 126 : 0, payload[4]];
         const signedData = bridgeSecurity.getSignedCommand(device, payload);
         if (!toolsSvc.canCommunicateWith(device.id)) return reject(new Error("Bridge not connected"));
         if (signedData.length > 110) {
@@ -1567,21 +1640,21 @@ const promiseQueue$1 = {
           );
         }
       });
-      return withTimeout(promise, 5e3, `Command timed out ${responseIdentifier}`);
+      return withTimeout(promise, 5e3, `Command timed out ${deviceResponseIdentifier[device.id]}, ${device.id}`);
     });
-    return promiseQueue;
+    return devicePromiseQueue[device.id];
   },
   async processMessage(deviceId, payload) {
     const numberArray = Array.from(new Uint8Array(payload));
     if (numberArray[3] === 127) {
       console.error(numberArray);
-      return currentReject(new Error(`Command not succesful: ${numberArray[4]}`));
+      return deviceCurrentReject[deviceId](new Error(`Command not succesful: ${numberArray[4]}`));
     }
     if ([226, 81].includes(numberArray[3]) && numberArray[4] && toolsSvc.canCommunicateWith(deviceId)) {
       store.bridgeRebootRequired[deviceId] = true;
     }
-    if ((!responseIdentifier[0] || numberArray[3] === responseIdentifier[0]) && (!responseIdentifier[1] || numberArray[4] === responseIdentifier[1])) {
-      return currentResolve(numberArray);
+    if ((!deviceResponseIdentifier[deviceId][0] || numberArray[3] === deviceResponseIdentifier[deviceId][0]) && (!deviceResponseIdentifier[deviceId][1] || numberArray[4] === deviceResponseIdentifier[deviceId][1])) {
+      return deviceCurrentResolve[deviceId](numberArray);
     }
     console.warn("message from the device not belonging to the pending promise: ", numberArray);
   }
@@ -1968,79 +2041,7 @@ const bridgeCommands = {
       }
       this.sendKeepAliveCommand(device);
     }, 1e4);
-    return promiseQueue$1.enqueue(device, writeCommand);
-  }
-};
-
-const otaServiceUuid = "1d14d6ee-fd63-4fa1-bfa4-8f47b42119f0";
-const otaControlCharacteristicUuid = "f7bf3564-fb6d-4e53-88a4-5e37e0326063";
-const otaDataCharacteristicUuid = "984227f3-34fc-4045-a5d0-2c581f81a153";
-const bridgeOtaCommands = {
-  async beginOta(deviceId) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([0]).buffer, true);
-  },
-  async uploadOtaChunk(deviceId, data) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data, true);
-  },
-  async endOta(deviceId) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer, true);
-  }
-};
-
-const bridgeOtaService = {
-  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
-    await delay(2e3);
-    progressCallback("Connecting to the bridge...", 0.1);
-    await bridgeOta.connect(deviceId);
-    progressCallback("Uploading bootloader...", 0.12);
-    await bridgeOtaCommands.beginOta(deviceId);
-    await uploadOta(deviceId, bootloader, (str, percents) => progressCallback(str, 0.12 + percents * 0.2));
-    await bridgeOtaCommands.endOta(deviceId);
-    progressCallback("Uploading application...", 0.32);
-    await bridgeOtaCommands.beginOta(deviceId);
-    await uploadOta(deviceId, firmware, (str, percents) => progressCallback(str, 0.32 + percents * 0.5));
-    await bridgeOtaCommands.endOta(deviceId);
-    progressCallback("Upload completed, disconnecting...", 0.81);
-    await bridgeOta.disconnect(deviceId);
-    progressCallback("Disconnected...", 1);
-  }
-};
-async function uploadOta(deviceId, firmwareBinary, reportStatus) {
-  let uploadedBytes = 0;
-  let chunkIndex = 0;
-  const mtu = store.platform === "android" ? 512 : deviceMeta.bridgeOta.mtu;
-  while (uploadedBytes < firmwareBinary.byteLength) {
-    if (chunkIndex % 100 === 0)
-      reportStatus(
-        `Uploading new firmware... (${_.round(uploadedBytes / 1e3)} / ${_.round(
-          firmwareBinary.byteLength / 1e3
-        )} KB)`,
-        uploadedBytes / firmwareBinary.byteLength
-      );
-    const chunkSize = Math.min(mtu - 3, firmwareBinary.byteLength - uploadedBytes);
-    const chunk = firmwareBinary.slice(uploadedBytes, uploadedBytes + chunkSize);
-    await bridgeOtaCommands.uploadOtaChunk(deviceId, chunk);
-    uploadedBytes += chunkSize;
-    chunkIndex++;
-  }
-}
-
-const bridgeOta = {
-  async connect(deviceId) {
-    await bluetooth.connect(deviceId, this.disconnect);
-    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
-    if (store.platform !== "ios") {
-      await ble.requestMtu(_deviceId, 512);
-    }
-    store.setState(deviceId, "paired");
-  },
-  async disconnect(deviceId, reason) {
-    store.setState(deviceId, "disconnecting");
-    await bluetooth.disconnect(deviceId);
-    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
-  },
-  async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
-    return bridgeOtaService.updateFirmware(deviceId, bootloader, firmware, progressCallback);
+    return promiseQueue.enqueue(device, writeCommand);
   }
 };
 
@@ -2062,8 +2063,13 @@ const bridgeService = {
   getVehicleReadings,
   resetAutolearnStatuses,
   getAutolearnStatuses,
-  isRebootRequired
+  isRebootRequired,
+  sendPinCommand
 };
+async function sendPinCommand(deviceId) {
+  if (!canCommunicateWith(deviceId)) throw new Error("Bridge not connected");
+  await bridgeCommands.sendPinCommand(deviceId);
+}
 async function updateFirmware(deviceId, bootloader, firmware, reportStatus) {
   reportStatus("Sending OTA Request...", 0.02);
   await bridgeCommands.sendOtaRequest(deviceId);
@@ -2385,7 +2391,7 @@ async function getVehicleReadings(deviceId, tcVehicle) {
   try {
     for (const vehicleTyre of tcVehicle.tcTyres) {
       if (vehicleTyre.tcTpmsSensor && vehicleTyre.mountedOn?.positionId) {
-        if (!canCommunicateWith(deviceId)) throw new Error("getVehicleReadings: no connected bridge");
+        if (!canCommunicateWith(deviceId)) break;
         const reading = await getSensorReading(deviceId, vehicleTyre.mountedOn.positionId);
         readings.push(reading);
       }
@@ -2683,12 +2689,28 @@ function isRebootRequired(deviceId) {
 
 const bridge = {
   disconnect,
-  async connect(deviceId, accessLevel) {
-    if (canCommunicateWith(deviceId)) return;
-    await promiseQueue$1.clearQueue("Previous pending commands aborted");
-    const bridgeMeta = deviceMeta.bridge;
-    await bluetooth.connect(deviceId, disconnect);
-    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+  connect,
+  getVehicle: bridgeService.getVehicle,
+  setVehicle: bridgeService.setVehicle,
+  getConfiguration: bridgeService.getConfiguration,
+  setConfiguration: bridgeService.setConfiguration,
+  getSensorReading: bridgeService.getSensorReading,
+  getVehicleReadings: bridgeService.getVehicleReadings,
+  getAutolearnStatuses: bridgeService.getAutolearnStatuses,
+  resetAutolearnStatuses: bridgeService.resetAutolearnStatuses,
+  updateFirmware: bridgeService.updateFirmware,
+  isRebootRequired: bridgeService.isRebootRequired
+};
+async function connect(deviceId, accessLevel) {
+  if (canCommunicateWith(deviceId)) return;
+  await promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
+  const bridgeMeta = deviceMeta.bridge;
+  await bluetooth.connect(deviceId, disconnect);
+  if (store.deviceState[deviceId] === "paired") {
+    return console.warn("Connect Warn: Already connected");
+  }
+  const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+  try {
     if (store.platform !== "ios") {
       await ble.requestMtu(_deviceId, deviceMeta.bridge.mtu);
     }
@@ -2696,28 +2718,22 @@ const bridge = {
       _deviceId,
       bridgeMeta.communication.serviceId,
       bridgeMeta.communication.characteristicId,
-      (notification) => promiseQueue$1.processMessage(deviceId, notification),
+      (notification) => promiseQueue.processMessage(deviceId, notification),
       (error) => console.error("startNotification Error", error)
     );
     store.deviceAccessLevel[deviceId] = accessLevel ?? "driver";
     store.bridgeRebootRequired[deviceId] = false;
-    await bridgeCommands.sendPinCommand(deviceId);
+    await bridgeService.sendPinCommand(deviceId);
     store.setState(deviceId, "paired");
-  },
-  getVehicle: bridgeService.getVehicle,
-  setVehicle: bridgeService.setVehicle,
-  getConfiguration: bridgeService.getConfiguration,
-  setConfiguration: bridgeService.setConfiguration,
-  getSensorReading: bridgeService.getSensorReading,
-  getVehicleReadings: bridgeService.getVehicleReadings,
-  getAutolearnStatuses: bridgeService.getAutolearnStatuses,
-  resetAutolearnStatuses: bridgeService.resetAutolearnStatuses,
-  updateFirmware: bridgeService.updateFirmware,
-  isRebootRequired: bridgeService.isRebootRequired
-};
+  } catch (e) {
+    disconnect(deviceId);
+    throw new Error(`Pairing unsuccessful ${e}`);
+  }
+}
 async function disconnect(deviceId, reason) {
+  await waitUntil(() => store.deviceState[deviceId] === "paired" || store.deviceState[deviceId] === void 0);
   store.setState(deviceId, "disconnecting");
-  promiseQueue$1.clearQueue("Previous pending commands aborted");
+  promiseQueue.clearQueue(deviceId, "Previous pending commands aborted");
   await bluetooth.disconnect(deviceId);
   delete store.devices[deviceId];
   deviceUnreachableCallback?.(deviceId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirecheck-device-sdk",
-  "version": "0.1.94",
+  "version": "0.1.95",
   "description": "SDK for working with various devices produced by Tirecheck via Bluetooth (CAN Bridge, Routers, Sensors, FlexiGauge, PressureStick, etc)",
   "author": "Leonid Buneev <leonid.buneev@tirecheck.com>",
   "license": "ISC",