tirecheck-device-sdk 0.1.8 → 0.1.91

package/dist/index.cjs

@@ -21,13 +21,15 @@ const store = {
   simulatedDevices: {},
   /** undefined - no information but since we get advertisings it is most likely disconnected, connecting - trying to connect via bluetooth, connected - connected via bluetooth (can send write and read), paired - all additional connection steps completed (setMtu, sendPin, etc) */
   deviceState: {},
-  // undefined => connecting => connected => paired => disconnecting => disconnected
+  // undefined => connecting => connected => paired => disconnecting => undefined
   bridgesReboot: {},
   //** Ios uses generated device Id, bridges send mac address in advertising so internaly we always use mac address but when real device id is needed we check mapping table for it */
   deviceIdMapingTable: {},
-  setState(deviceId, state) {
+  /** Used to change device state in store, also notifies app via calback. Every undefined state should have its reason so that app can handle it accordingly */
+  setState(deviceId, state, reason) {
+    if (state === void 0 && !reason) console.error("setState called with undefined state and no reason");
     this.deviceState[deviceId] = state;
-    deviceStateChangeCallback?.(deviceId, state);
+    deviceStateChangeCallback?.(deviceId, state, reason);
   }
 };
 
@@ -147,6 +149,9 @@ const bridgeTools = {
     if (displayUnits === "decimal") {
       return Number(`0x${_reversedData.map((dec) => this.decimalToHex(dec)).join("")}`.replace(/\r\n/g, ""));
     }
+    if (displayUnits === "reverseHex") {
+      return _reversedData.map((dec) => this.decimalToHex(dec).split("").reverse().join("")).join("");
+    }
     return _reversedData.map((dec) => this.decimalToHex(dec)).join("");
   },
   encodeData(data, displayUnits) {
@@ -157,6 +162,11 @@ const bridgeTools = {
     if (displayUnits === "decimal") {
       return this.hexToDecimalArray(this.decimalToHex(_data)).reverse();
     }
+    if (displayUnits === "reverseHex") {
+      const byteArray = _data.match(/.{1,2}/g) || [];
+      const reversedBytes = byteArray.map((b) => b.split("").reverse().join(""));
+      return this.hexToDecimalArray(reversedBytes.join("")).reverse();
+    }
     return this.hexToDecimalArray(_data).reverse();
   },
   //   getBridgeId(device: BluetoothDeviceBridge) {
@@ -322,7 +332,8 @@ const bridgeAdvertisingParser = {
 };
 function getAdvertisingType(device) {
   if (device.advertising?.kCBAdvDataIsConnectable) {
-    return "connectable";
+    const adv = Array.from(new Uint8Array(device.advertising.kCBAdvDataManufacturerData));
+    return adv.length > 34 ? "connectable" : "unknown";
   }
   const numberArray = Array.from(new Uint8Array(device.advertising));
   if (___default.isEqual(numberArray.slice(0, 4), [2, 1, 6, 7])) {
@@ -414,11 +425,8 @@ const bridgeOtaAdvertisingParser = {
     let bridgeId = "";
     let processedByteCount = 0;
     if (store.platform === "ios") {
-      if (!device.advertising.kCBAdvDataLeBluetoothDeviceAddress)
-        return console.warn("No mac address in advertising data");
-      const macAddress = Array.from(new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)).map(
-        (x) => bridgeTools.decimalToHex(x).toUpperCase()
-      );
+      if (!device.advertising.kCBAdvDataLeBluetoothDeviceAddress) return void 0;
+      const macAddress = Array.from(new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)).slice(-6).reverse().map((x) => bridgeTools.decimalToHex(x).toUpperCase());
       deviceId = macAddress.join(":");
       bridgeId = macAddress.join("");
     } else {
@@ -438,7 +446,7 @@ const bridgeOtaAdvertisingParser = {
         }
       } while (processedByteCount < adv.length);
     }
-    if (!deviceId) return console.warn("Failed to get device Id");
+    if (!deviceId) return void 0;
     store.deviceIdMapingTable[deviceId] = device.id;
     const bleDevice = {
       ...device,
@@ -463,6 +471,7 @@ const deviceMeta = {
   },
   bridgeOta: {
     nameRegex: /(CAN BLE BRDG OTA.*|0303.{2}_B)/,
+    mtu: store.platform === "android" ? 512 : 180,
     characteristic: {
       serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
       characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
@@ -515,19 +524,17 @@ const deviceMeta = {
 const checkUnreachableDevicesTimeouts = {};
 let deviceAdvertisingCallback;
 let deviceUnreachableCallback;
-let deviceLostConnectionCallback;
 let deviceStateChangeCallback;
 const bluetooth = {
   /** Triggered when "scanDevices" detects device supported by SDK */
   onDeviceAdvertising(callback) {
     deviceAdvertisingCallback = callback;
   },
+  /** Triggered when device doesnt send advertisement for 60 seconds */
   onDeviceUnreachable(callback) {
     deviceUnreachableCallback = callback;
   },
-  onDeviceLostConnection(callback) {
-    deviceLostConnectionCallback = callback;
-  },
+  /** Triggered when device changed state, allows app to react to state changes */
   onDeviceStateChange(callback) {
     deviceStateChangeCallback = callback;
   },
@@ -572,13 +579,17 @@ async function connect(deviceId, disconnectCallback) {
       if (connectedDevice) break;
     } catch (e) {
       console.warn(`${attempt} connect fail`, e);
-      if (attempt === 3) throw new Error("Connection unsuccessful");
+      if (attempt === 3) {
+        store.setState(deviceId, void 0, "failedConnection");
+        throw new Error("Connection unsuccessful");
+      }
     }
   }
+  clearTimeout(checkUnreachableDevicesTimeouts[deviceId]);
   const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
   const isConnected = await ble.isConnected(_deviceId);
   if (!isConnected) {
-    store.setState(deviceId, void 0);
+    store.setState(deviceId, void 0, "failedConnection");
     throw new Error("Connect Error");
   }
   store.setState(deviceId, "connected");
@@ -589,8 +600,7 @@ function connectInner(deviceId, disconnectCallback) {
   return new Promise(
     (resolve, reject) => ble.connect(_deviceId, resolve, (err) => {
       if (toolsSvc.canCommunicateWith(deviceId)) {
-        deviceLostConnectionCallback?.(deviceId);
-        disconnectCallback(deviceId);
+        disconnectCallback(deviceId, "lostConnection");
       }
       reject(err);
     })
@@ -603,14 +613,18 @@ async function disconnect(deviceId) {
     const isConnected = await ble.isConnected(_deviceId);
     if (!isConnected) return;
   }
-  store.setState(deviceId, void 0);
+  store.setState(deviceId, void 0, "failedDisconnection");
   throw new Error("Disconnect unsuccessful");
 }
-async function write(deviceId, serviceUuid, characteristicUuid, value) {
+async function write(deviceId, serviceUuid, characteristicUuid, value, withResponse) {
   if (!toolsSvc.canCommunicateWith(deviceId)) throw new Error("Write Error: Not connected to device");
   try {
     const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
-    await ble.writeWithoutResponse(_deviceId, serviceUuid, characteristicUuid, value);
+    if (withResponse) {
+      await ble.write(_deviceId, serviceUuid, characteristicUuid, value);
+    } else {
+      await ble.writeWithoutResponse(_deviceId, serviceUuid, characteristicUuid, value);
+    }
   } catch (e) {
     throw new Error(`Write Error: ${e}`);
   }
@@ -657,7 +671,7 @@ function refreshUnreachableTimeouts(deviceId) {
     clearTimeout(checkUnreachableDevicesTimeouts[deviceId]);
   }
   checkUnreachableDevicesTimeouts[deviceId] = setTimeout(() => {
-    store.setState(deviceId, void 0);
+    delete store.devices[deviceId];
     deviceUnreachableCallback?.(deviceId);
   }, 6e4);
 }
@@ -1165,63 +1179,78 @@ const bridgeCommandStructures = {
     structure: {
       axle01: {
         size: 8,
-        description: "Axle 01 autolearn statuses, each nibble signifies a single wheel."
+        description: "Axle 01 autolearn statuses, each nibble signifies a single wheel.",
+        display: "reverseHex"
       },
       axle02: {
         size: 8,
-        description: "Axle 02 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 02 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle03: {
         size: 8,
-        description: "Axle 03 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 03 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle04: {
         size: 8,
-        description: "Axle 04 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 04 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle05: {
         size: 8,
-        description: "Axle 05 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 05 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle06: {
         size: 8,
-        description: "Axle 06 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 06 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle07: {
         size: 8,
-        description: "Axle 07 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 07 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle08: {
         size: 8,
-        description: "Axle 08 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 08 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle09: {
         size: 8,
-        description: "Axle 09 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 09 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle10: {
         size: 8,
-        description: "Axle 10 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 10 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle11: {
         size: 8,
-        description: "Axle 11 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 11 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle12: {
         size: 8,
-        description: "Axle 12 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 12 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle13: {
         size: 8,
-        description: "Axle 13 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 13 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle14: {
         size: 8,
-        description: "Axle 14 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 14 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       },
       axle15: {
         size: 8,
-        description: "Axle 15 autolearn statuses, each nibble signifies a single wheel"
+        description: "Axle 15 autolearn statuses, each nibble signifies a single wheel",
+        display: "reverseHex"
       }
     }
   },
@@ -1290,6 +1319,88 @@ const bridgeCommandStructures = {
         description: "Unknown sensor data"
       }
     }
+  },
+  vehicleLayout: {
+    id: [98, 1],
+    name: "vehicleLayout",
+    structure: {
+      axle01: {
+        size: 2,
+        description: "Axle 01 each bit represents present tyre."
+      },
+      axle02: {
+        size: 2,
+        description: "Axle 02 each bit represents present tyre"
+      },
+      axle03: {
+        size: 2,
+        description: "Axle 03 each bit represents present tyre"
+      },
+      axle04: {
+        size: 2,
+        description: "Axle 04 each bit represents present tyre"
+      },
+      axle05: {
+        size: 2,
+        description: "Axle 05 each bit represents present tyre"
+      },
+      axle06: {
+        size: 2,
+        description: "Axle 06 each bit represents present tyre"
+      },
+      axle07: {
+        size: 2,
+        description: "Axle 07 each bit represents present tyre"
+      },
+      axle08: {
+        size: 2,
+        description: "Axle 08 each bit represents present tyre"
+      },
+      axle09: {
+        size: 2,
+        description: "Axle 09 each bit represents present tyre"
+      },
+      axle10: {
+        size: 2,
+        description: "Axle 10 each bit represents present tyre"
+      },
+      axle11: {
+        size: 2,
+        description: "Axle 11 each bit represents present tyre"
+      },
+      axle12: {
+        size: 2,
+        description: "Axle 12 each bit represents present tyre"
+      },
+      axle13: {
+        size: 2,
+        description: "Axle 13 each bit represents present tyre"
+      },
+      axle14: {
+        size: 2,
+        description: "Axle 14 each bit represents present tyre"
+      },
+      axle15: {
+        size: 2,
+        description: "Axle 15 each bit represents present tyre"
+      },
+      vin: {
+        size: 17,
+        description: "Vehicle Identification Number",
+        display: "ascii"
+      },
+      vinExtension: {
+        size: 1,
+        description: "VIN extension",
+        display: "ascii",
+        optional: true
+      },
+      test: {
+        size: 3,
+        description: "Test",
+        optional: true
+      }
+    }
   }
 };
 
@@ -1547,13 +1658,14 @@ const promiseQueue$1 = {
           );
         }
       });
-      return withTimeout(promise, 5e3, "Command timed out");
+      return withTimeout(promise, 5e3, `Command timed out ${responseIdentifier}`);
     });
     return promiseQueue;
   },
   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]}`));
     }
     if ([226, 81].includes(numberArray[3]) && numberArray[4] && toolsSvc.canCommunicateWith(deviceId)) {
@@ -1956,7 +2068,7 @@ const bridgeCommands = {
     if (!canCommunicateWith(device.id)) throw new Error("Bridge not connected");
     clearTimeout(keepAliveTimer);
     keepAliveTimer = setTimeout(() => {
-      if (!canCommunicateWith(device.id)) {
+      if (store.deviceState[device.id] !== "paired" || store.devices[device.id]?.type !== "bridge") {
         return;
       }
       this.sendKeepAliveCommand(device);
@@ -1970,17 +2082,16 @@ 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);
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([0]).buffer, true);
   },
   async uploadOtaChunk(deviceId, data) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data);
+    await bluetooth.write(deviceId, otaServiceUuid, otaDataCharacteristicUuid, data, true);
   },
   async endOta(deviceId) {
-    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer);
+    await bluetooth.write(deviceId, otaServiceUuid, otaControlCharacteristicUuid, new Uint8Array([3]).buffer, true);
   }
 };
 
-const mtu = store.platform === "android" ? 512 : 180;
 const bridgeOtaService = {
   async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
     await delay(2e3);
@@ -2010,7 +2121,7 @@ async function uploadOta(deviceId, firmwareBinary, reportStatus) {
         )} KB)`,
         uploadedBytes / firmwareBinary.byteLength
       );
-    const chunkSize = Math.min(mtu - 3, firmwareBinary.byteLength - uploadedBytes);
+    const chunkSize = Math.min(deviceMeta.bridgeOta.mtu - 3, firmwareBinary.byteLength - uploadedBytes);
     const chunk = firmwareBinary.slice(uploadedBytes, uploadedBytes + chunkSize);
     await bridgeOtaCommands.uploadOtaChunk(deviceId, chunk);
     uploadedBytes += chunkSize;
@@ -2021,12 +2132,14 @@ async function uploadOta(deviceId, firmwareBinary, reportStatus) {
 const bridgeOta = {
   async connect(deviceId) {
     await bluetooth.connect(deviceId, this.disconnect);
+    const _deviceId = store.deviceIdMapingTable[deviceId] ?? deviceId;
+    await ble.requestMtu(_deviceId, deviceMeta.bridgeOta.mtu);
     store.setState(deviceId, "paired");
   },
-  async disconnect(deviceId) {
+  async disconnect(deviceId, reason) {
     store.setState(deviceId, "disconnecting");
     await bluetooth.disconnect(deviceId);
-    store.setState(deviceId, "disconnected");
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
   },
   async updateFirmware(deviceId, bootloader, firmware, progressCallback) {
     return bridgeOtaService.updateFirmware(deviceId, bootloader, firmware, progressCallback);
@@ -2055,6 +2168,7 @@ const bridgeService = {
 async function updateFirmware(deviceId, bootloader, firmware, reportStatus) {
   reportStatus("Sending OTA Request...", 0.02);
   await bridgeCommands.sendOtaRequest(deviceId);
+  await bridge.disconnect(deviceId, "firmwareUpdate");
   await toolsSvc.delay(2e3);
   await bluetooth.scanDevices();
   reportStatus("Discovering OTA Device...", 0.02);
@@ -2365,7 +2479,8 @@ async function getSensorReading(deviceId, positionId) {
     sensorStatus: value[12],
     eceStatus: value[13],
     pressureIssue: getPressureIssue(deviceId, value[13]),
-    ...getPressureAndTemperatureReadingObjects(value[9], value[10])
+    ...getPressureAndTemperatureReadingObjects(value[9], value[10]),
+    byteReading: value
   };
 }
 async function getVehicleReadings(deviceId, tcVehicle) {
@@ -2687,11 +2802,13 @@ const bridge = {
     await bridgeCommands.sendPinCommand(deviceId);
     store.setState(deviceId, "paired");
   },
-  async disconnect(deviceId) {
+  async disconnect(deviceId, reason) {
     store.setState(deviceId, "disconnecting");
     promiseQueue$1.clearQueue("Previous pending commands aborted");
     await bluetooth.disconnect(deviceId);
-    store.setState(deviceId, "disconnected");
+    delete store.devices[deviceId];
+    deviceUnreachableCallback?.(deviceId);
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
   },
   getVehicle: bridgeService.getVehicle,
   setVehicle: bridgeService.setVehicle,
@@ -2827,10 +2944,10 @@ const flexiGaugeTpms = {
     );
     store.setState(deviceId, "paired");
   },
-  async disconnect(deviceId) {
+  async disconnect(deviceId, reason) {
     store.setState(deviceId, "disconnecting");
     await bluetooth.disconnect(deviceId);
-    store.setState(deviceId, "disconnected");
+    store.setState(deviceId, void 0, reason ?? "manualDisconnection");
   },
   onTreadDepth(callback) {
     flexiGaugeTpmsService.onTreadDepth(callback);
@@ -2901,7 +3018,7 @@ const bridgeSimulator = {
   async disconnect(deviceId) {
     store.deviceState[deviceId] = "disconnecting";
     await toolsSvc.delay(100);
-    store.deviceState[deviceId] = "disconnected";
+    store.deviceState[deviceId] = void 0;
   },
   createSimulatedBridge(initialData) {
     return {
@@ -2928,7 +3045,8 @@ const bridgeSimulator = {
             sensorStatus: 0,
             pressure: { bar: 0, meas: 0, raw: 0 },
             pressureIssue: void 0,
-            temperature: { amb: 0, celsius: 0, raw: 0 }
+            temperature: { amb: 0, celsius: 0, raw: 0 },
+            byteReading: [0, 0, 0, 0, 0, 0, 0, 0]
           }
         },
         vehicle: {