tirecheck-device-sdk 0.1.0

package/README.md

@@ -0,0 +1,126 @@
+# Tirecheck Device SDK
+
+## Usage
+
+First, install this library as a dependency to your application:
+
+```
+pnpm add tirecheck-device-sdk
+```
+
+Then, create an instance of this SDK. You will need to provide implementation for basic bluetooth methods on your
+environment - this library is optimized for usage with `cordova-plugin-ble-central` on mobile devices, but you can
+provide any other implementation:
+
+```
+// tirecheckDeviceSdk.ts
+import { createTirecheckDeviceSdk } from 'tirecheck-device-sdk'
+
+export default createTirecheckDeviceSdk({
+  // See typescript definitions for more info
+  startScanWithOptions: ...
+  connect: ...
+  write: ...
+  read: ...
+})
+
+
+// OR, if you're using `cordova-plugin-ble-central`:
+export default createTirecheckDeviceSdk(window.ble.withPromises)
+```
+
+Example library usage:
+
+```
+const foundBridges = {}
+
+tirecheckDeviceSdk.bluetooth.scanDevices(device => {
+  if(device.type === 'bridge') foundBridges[device.id] = device
+})
+
+await tirecheckDeviceSdk.bridge.connect(deviceId)
+
+await tirecheckDeviceSdk.bridge.readVehicleSchema(deviceId)
+```
+
+## Contributing
+
+### Getting started
+
+1. Install Node.js 20.0+
+2. Clone this repo
+3. Run `corepack enable` (sometimes `sudo corepack enable` is needed)
+4. `pnpm dev`
+
+That should open Vitest's UI. Feel free to add new functionality and tests.
+
+### Test-driven development
+
+For this project, we advice to follow TDD for every feature. That means that you first write failing test, and then add
+implementation so that test passes.
+
+Focus on one small improvement at a time - one failing test, then make it pass, then another failing test, etc. Mentally
+this approach is much easier because you don't need to think about system as a whole
+
+### Conventions
+
+- use `deviceMeta` for storing generic device info and methods for processing advertisement for all supported devices
+  - this is to avoid importing full device services before we're connected to them
+- use `devices/*` for exposed logic related to devices after they're connected. That includes methods `connect` and
+  `disconnect`.
+- use `services/*` for logic shared between devices. Those files won't be exposed in the build.
+- expose only top-level functions. So, expose `bridge.writeConfiguration` or `bridge.writeAxleSetup` instead of generic
+  `bridge.writeMessage`
+- in device services, use verbs `read*` and `write*` for methods that primarily read/write to/from device
+- use `on*` for "subscription" methods - e.g. `tirecheckDeviceSdk.bridge.onMeasurementReceived(callback)`
+- for devices that expose additional info via advertisings, do not report them while advertising data is incomplete.
+- don't use `this` keyword.
+
+```
+// Bad
+export default {
+  foo() {},
+  bar() {
+    this.foo()
+  }
+}
+
+// Good
+export default {
+  foo,
+  bar() {
+    foo()
+  }
+}
+
+function foo() {}
+```
+
+### Submitting changes
+
+If you wish to include a new change, process is as follows:
+
+- You need to have a Jira ticket related to your change
+- Create a new branch from latest `main` that includes your name and ticket number from Jira, e.g.
+  `leonid-buneev/INF-1234`
+- Commit and push your changes to this new branch.
+- Create a Merge Request in https://tycgitlab.tyrecheck.com/leonid.buneev/tirecheck-device-sdk/-/merge_requests
+- Wait for review
+- After ticket is merged, new SDK version will be published to NPM automatically.
+- Bump version of `tirecheck-device-sdk` in the `package.json` of your app to download latest SDK version.
+
+## Support
+
+You can contact tirecheck if you need support - admin@tirecheck.com
+
+## Roadmap
+
+[x] Initial structure
+
+[] Full CAN bridge support
+
+[] CAN Bridge Firmware Update support
+
+[] FlexiGauge
+
+[] TPMS Router

package/dist/index.cjs

@@ -0,0 +1,431 @@
+'use strict';
+
+const _ = require('lodash');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ___default = /*#__PURE__*/_interopDefaultCompat(_);
+
+let ble;
+function setBleImplementation(bleImplementation) {
+  ble = bleImplementation;
+}
+
+const bridgeTools = {
+  //   convertBytesToStructure(objStructure: BridgeCommandStructureProperties, payload: number[]) {
+  //     const numArray = _.clone(payload)
+  //     const keys = Object.keys(objStructure)
+  //     const sumWithInitial = keys.reduce((accumulator, currentValue) => accumulator + objStructure[currentValue].size, 0)
+  //     if (numArray.length !== sumWithInitial) {
+  //       throw new Error('Cannot convert bytes to object')
+  //     }
+  //     const result: any = {}
+  //     for (const key of keys) {
+  //       const encodedData: number[] = numArray.splice(0, objStructure[key].size)
+  //       result[key] = this.decodeData(encodedData, objStructure[key].display)
+  //     }
+  //     return result
+  //   },
+  //   convertStructureToBytes(objStructure: any, structurizedObj: any) {
+  //     const keys = Object.keys(objStructure)
+  //     const result: number[] = []
+  //     for (const key of keys) {
+  //       const encoded = this.encodeData(structurizedObj[key], objStructure[key].display)
+  //       if (encoded.length < objStructure[key].size) {
+  //         const _padArray = Array.from({ length: objStructure[key].size - encoded.length }, () => 0)
+  //         encoded.push(..._padArray)
+  //       }
+  //       result.push(...encoded)
+  //     }
+  //     return result
+  //   },
+  //   convertAutoLearnObjectToBinary(data: Record<string, string>): Record<string, string> {
+  //     const result: Record<string, string> = {}
+  //     for (const key in data) {
+  //       if (!key.includes('axle')) continue
+  //       // Parse the value as hexadecimal (base 16)
+  //       const value = parseInt(data[key], 16)
+  //       // Convert to binary and pad with leading zeros to ensure 8 characters
+  //       const binaryString = value.toString(2).padStart(8, '0')
+  //       result[key] = binaryString
+  //     }
+  //     return result
+  //   },
+  //   decodeData(data: number[], displayUnits: undefined | 'ascii' | 'decimal') {
+  //     const _data = _.clone(data)
+  //     if (displayUnits === 'ascii') {
+  //       return _data
+  //         .filter(d => d)
+  //         .map(x => String.fromCharCode(x))
+  //         .join('')
+  //     }
+  //     const _reversedData = _data.reverse()
+  //     if (displayUnits === 'decimal') {
+  //       return Number(`0x${_reversedData.map(dec => this.decimalToHex(dec)).join('')}`.replace(/\r\n/g, ''))
+  //     }
+  //     return _reversedData.map(dec => this.decimalToHex(dec)).join('')
+  //   },
+  //   encodeData(data: number | string, displayUnits: undefined | 'ascii' | 'decimal'): number[] {
+  //     const _data = _.clone(data)
+  //     if (displayUnits === 'ascii') {
+  //       return (_data as string).split('').map((v, i) => (_data as string).charCodeAt(i))
+  //     }
+  //     if (displayUnits === 'decimal') {
+  //       return this.hexToDecimalArray(this.decimalToHex(_data as number)).reverse()
+  //     }
+  //     return this.hexToDecimalArray(_data as string).reverse()
+  //   },
+  //   getBridgeId(device: BluetoothDeviceBridge) {
+  //     // [244,177, 0, 34,123, 155] => F4B100227B9B
+  //     return (
+  //       device.advertisingData.macAddress
+  //         ?.map(n => this.decimalToHex(n))
+  //         .reverse()
+  //         .join('')
+  //         .toUpperCase() || ''
+  //     )
+  //   },
+  //   pkcs(array: any[], length: number) {
+  //     const pkcsValue = length - array.length
+  //     if (pkcsValue > 0) {
+  //       return [...array, ...new Array(pkcsValue).fill(pkcsValue)]
+  //     }
+  //     return array
+  //   },
+  decimalToHex(decimal) {
+    const hex = decimal.toString(16);
+    return hex.padStart(2, "0");
+  },
+  //   hexToDecimalArray(hex: string): number[] {
+  //     return hex.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []
+  //   },
+  getFwVersion(payload) {
+    if (payload?.length !== 3) {
+      console.warn("Could not process FwVersion ", payload);
+      return "";
+    }
+    return payload.reduce((acc, current) => {
+      const value = this.decimalToHex(current);
+      acc.push(value[0] === "0" ? value[1] : value);
+      return acc;
+    }, []).join(".");
+  }
+  //   barToKpaByte(value?: number) {
+  //     if (!value) return 0
+  //     return _.round(((value + 1) * 100) / 5.0625)
+  //   },
+  //   kpaByteToBar(value?: number, decrementValue = 1) {
+  //     if (!_.isNumber(value)) {
+  //       throw new TypeError('Value has to be a number')
+  //     }
+  //     const rawBar = (value * 5.0625) / 100
+  //     return Math.max(rawBar - decrementValue, 0)
+  //   },
+  //   getMacAddressIfOtaAndIos(device: BluetoothDeviceBridge) {
+  //     const uint8 = new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)
+  //     const macAddressArray = Array.from(uint8)
+  //       .reverse()
+  //       .slice(0, 6)
+  //       .map(x => this.decimalToHex(x).toUpperCase())
+  //     return macAddressArray.join('')
+  //   },
+  //   isVersionGreaterThan(version: string) {
+  //     if (version?.length !== 5) {
+  //       throw new Error('Invalid version format'.t())
+  //     }
+  //     if (bluetoothStore?.connectedBridge?.advertisingData?.fwVersion) {
+  //       return bluetoothStore?.connectedBridge?.advertisingData?.fwVersion > version
+  //     }
+  //     return false
+  //   },
+};
+
+const bridgeAdvertisingParser = {
+  getDeviceInfoFromAdvertising(device) {
+    const adversitingType = getAdvertisingType(device);
+    if (adversitingType !== "connectable")
+      return void 0;
+    const advertisingData = getAdvertisingData({ advertising: device.advertising, deviceName: device.name });
+    const bridgeId = advertisingData?.macAddress?.map((n) => bridgeTools.decimalToHex(n)).reverse().join("").toUpperCase() || "";
+    const vin = String.fromCharCode(...advertisingData?.vinNum || []).split("\0").join("");
+    return { id: device.id, name: device.name, bridgeId, vin, advertisingData, device };
+  }
+};
+function getAdvertisingType(device) {
+  if (device.advertising?.kCBAdvDataIsConnectable) {
+    return "connectable";
+  }
+  const numberArray = Array.from(new Uint8Array(device.advertising));
+  if (___default.isEqual(numberArray.slice(0, 4), [2, 1, 6, 7])) {
+    return "connectable";
+  }
+  if (numberArray[3] === 26) {
+    return "krone";
+  }
+  if (___default.isEqual(numberArray.slice(0, 4), [2, 1, 6, 3])) {
+    return "measurement";
+  }
+  return "unknown";
+}
+function getAdvertisingData({ advertising, deviceName }) {
+  const isKrone = deviceName === "030321";
+  const uint8 = new Uint8Array(
+    advertising.kCBAdvDataIsConnectable ? advertising.kCBAdvDataManufacturerData : advertising
+  );
+  const adv = Array.from(uint8);
+  const advertisingData = advertising.kCBAdvDataIsConnectable ? processIosAdvertising(adv) : processAndroidAdvertising(adv, isKrone);
+  if (!advertisingData || !advertisingData.macAddress.length || !advertisingData.randomAdvNumber.length || !advertisingData.vinNum.length) {
+    throw new Error("Device not recognized");
+  }
+  return advertisingData;
+}
+function processAndroidAdvertising(adv, isKrone) {
+  const advertisingData = {
+    configVersion: isKrone ? 17 : 1,
+    macAddress: [],
+    randomAdvNumber: [],
+    vinNum: [],
+    fwVersion: void 0,
+    timeFromStart: void 0
+  };
+  do {
+    const length = adv[0];
+    const identificator = adv[1];
+    const messageType = adv[4];
+    const packet = adv.splice(0, length + 1);
+    if (!length) {
+      adv = [];
+    }
+    if (messageType === 3 && identificator === 255) {
+      advertisingData.macAddress = packet.slice(5, 11);
+      advertisingData.vinNum = packet.slice(-17);
+    }
+    if (messageType === 1 && identificator === 255) {
+      advertisingData.randomAdvNumber = packet.slice(-8);
+    }
+    if (messageType === 4 && identificator === 255) {
+      advertisingData.randomAdvNumber = packet.slice(5, 13);
+      advertisingData.fwVersion = bridgeTools.getFwVersion(packet.slice(13, 16));
+      advertisingData.configVersion = packet[16];
+      advertisingData.timeFromStart = packet[17];
+    }
+  } while (adv.length);
+  return advertisingData;
+}
+function processIosAdvertising(adv, isKrone) {
+  if (adv.length < 34)
+    return void 0;
+  if (adv.length === 35) {
+    adv.slice(3, 11);
+    adv.slice(12, 18);
+    adv.slice(18, 35);
+  }
+  if (adv.length === 40) {
+    adv.slice(3, 11);
+    bridgeTools.getFwVersion(adv.slice(11, 14));
+    adv[14];
+    adv[15];
+    adv.slice(17, 23);
+    adv.slice(23, 40);
+  }
+}
+
+const deviceMeta = {
+  bridge: {
+    nameRegex: /(030303|030321)/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      // message from device
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
+    },
+    capabilities: [],
+    manufacturerId: 2978,
+    mtu: 256,
+    getDeviceInfoFromAdvertising: bridgeAdvertisingParser.getDeviceInfoFromAdvertising
+  },
+  bridgeOta: {
+    nameRegex: /CAN BLE BRDG OTA.*/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
+    },
+    capabilities: [],
+    getDeviceInfoFromAdvertising: () => {
+    }
+  },
+  flexiGaugeTpms: {
+    nameRegex: /Flexi.*/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      // message from device
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
+    },
+    getDeviceInfoFromAdvertising: () => {
+    },
+    // Do we need it here?
+    capabilities: [
+      {
+        id: "td",
+        // processFn: processTreadDepth,
+        regex: /^\*TD.*/
+      },
+      {
+        id: "button",
+        // processFn: processButtonPress,
+        regex: /^\*[UDLRC] $/
+      },
+      {
+        id: "tpms",
+        // processFn: processTpms,
+        regex: /^\*TPMS.*/
+      }
+    ],
+    reconnect: true
+    // Do we need it here?
+  },
+  pressureStick: {
+    nameRegex: /Pressure Stick.*/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
+    },
+    getDeviceInfoFromAdvertising: () => {
+    },
+    capabilities: [
+      {
+        id: "pressure",
+        // processFn: processPressure,
+        regex: /P([0-9.]+)mBar/
+      }
+      // only pressure is needed for initial implementation, uncomment tpms functionality when needed
+      // {
+      //   id: 'tpms',
+      //   processFn: processTpms,
+      //   regex: /^\*TPMS/,
+      // },
+    ]
+  }
+};
+
+const checkUnreachableDevicesTimeouts = {};
+const checkConnectedStateIntervals = {};
+const deviceAdvertisingCallbacks = [];
+const deviceUpdateCallbacks = [];
+const deviceUnreachableCallbacks = [];
+const bluetooth = {
+  /** Triggered when "scanDevices" detects device supported by SDK */
+  onDeviceAdvertising(deviceAdvertisingCallback) {
+    deviceAdvertisingCallbacks.push(deviceAdvertisingCallback);
+  },
+  onDeviceUpdate(deviceUpdateCallback) {
+    deviceUpdateCallbacks.push(deviceUpdateCallback);
+  },
+  onDeviceUnreachable(deviceUnreachableCallback) {
+    deviceUnreachableCallbacks.push(deviceUnreachableCallback);
+  },
+  async scanDevices(services = []) {
+    await ble.stopScan();
+    ble.startScanWithOptions(
+      services,
+      {
+        reportDuplicates: true,
+        matchMode: "aggressive",
+        scanMode: "lowLatency",
+        numOfMatches: "max",
+        callbackType: "all",
+        reportDelay: 0
+      },
+      (device) => {
+        const processedDevice = processDevice(device);
+        if (!processedDevice)
+          return;
+        for (const c of deviceAdvertisingCallbacks) {
+          c(processedDevice);
+        }
+      },
+      (e) => console.error("ble.startScanWithOptions error:", e)
+    );
+  }
+};
+function processDevice(device) {
+  const uint8 = new Uint8Array(device.advertising);
+  const adv = Array.from(uint8);
+  let name = device.advertising.kCBAdvDataLocalName || device.name;
+  if (!name || name === "OTA") {
+    name = getDeviceNameFromAdvertising(adv);
+  }
+  const deviceType = getDeviceTypeFromName(name);
+  if (!deviceType) {
+    return;
+  }
+  let processedDevice;
+  try {
+    processedDevice = deviceMeta[deviceType].getDeviceInfoFromAdvertising({ ...device, name });
+    if (!processedDevice)
+      return;
+  } catch (e) {
+    console.warn("Error processing advertising", e);
+    return;
+  }
+  refreshUnreachableTimeouts(processedDevice.id);
+  monitorConnectedState(processedDevice.id);
+  return processedDevice;
+}
+function getDeviceTypeFromName(name) {
+  let deviceType;
+  for (const key in deviceMeta) {
+    const meta = deviceMeta[key];
+    if (meta.nameRegex.test(name)) {
+      deviceType = key;
+    }
+  }
+  return deviceType;
+}
+function monitorConnectedState(deviceId) {
+  if (checkConnectedStateIntervals[deviceId])
+    return;
+  checkConnectedStateIntervals[deviceId] = setInterval(async () => {
+    let isConnected = false;
+    try {
+      await ble.isConnected(deviceId);
+      isConnected = true;
+    } catch {
+      isConnected = false;
+    }
+    for (const c of deviceUpdateCallbacks) {
+      c({ deviceId, isConnected });
+    }
+  }, 1e3);
+}
+function refreshUnreachableTimeouts(deviceId) {
+  if (checkUnreachableDevicesTimeouts[deviceId]) {
+    clearTimeout(checkUnreachableDevicesTimeouts[deviceId]);
+  }
+  checkUnreachableDevicesTimeouts[deviceId] = setTimeout(() => {
+    for (const c of deviceUnreachableCallbacks) {
+      c(deviceId);
+    }
+    if (checkConnectedStateIntervals[deviceId]) {
+      clearInterval(checkConnectedStateIntervals[deviceId]);
+      delete checkConnectedStateIntervals[deviceId];
+    }
+  }, 6e4);
+}
+function getDeviceNameFromAdvertising(adv) {
+  const advertising = ___default.clone(adv);
+  const messageType = advertising[4];
+  const packet = advertising.slice(5, 11);
+  if (messageType === 9) {
+    return packet.map((x) => String.fromCharCode(x)).join("");
+  }
+  return "";
+}
+
+function createTirecheckDeviceSdk(bleImplementation) {
+  setBleImplementation(bleImplementation);
+  return {
+    bluetooth
+  };
+}
+
+exports.createTirecheckDeviceSdk = createTirecheckDeviceSdk;

package/dist/index.d.cts

@@ -0,0 +1,68 @@
+interface BleImplementation {
+    startScanWithOptions: (services: string[], options: StartScanOptions, success: (data: PeripheralData) => any, failure?: (error: string) => any) => void;
+    stopScan: () => Promise<void>;
+    /** Returns a resolved promise if the device is connected,
+    otherwise returns rejected promise if the device is not connected */
+    isConnected: ((deviceId: string) => Promise<void>) & ((deviceId: string, rejectWhenDisconnected: false) => Promise<boolean>);
+}
+interface StartScanOptions {
+    scanMode?: 'lowPower' | 'balanced' | 'lowLatency' | 'opportunistic';
+    callbackType?: 'all' | 'first' | 'lost';
+    matchMode?: 'aggressive' | 'sticky';
+    numOfMatches?: 'one' | 'few' | 'max';
+    phy?: '1m' | 'coded' | 'all';
+    legacy?: boolean;
+    reportDelay?: number;
+    forceScanFilter?: number;
+    reportDuplicates?: boolean;
+    /** Scanning duration in seconds */
+    duration?: number;
+}
+interface PeripheralData {
+    name: string;
+    id: string;
+    rssi: number;
+    advertising: ArrayBuffer | any;
+    connectable?: boolean;
+    state: PeripheralState;
+}
+type PeripheralState = 'disconnected' | 'disconnecting' | 'connecting' | 'connected';
+
+type BleDevice = BleBridge;
+interface BleBridge {
+    id: string;
+    name: string;
+    bridgeId: string;
+    vin: string;
+    advertisingData: BleBridgeAdvertisingData;
+    device: PeripheralData;
+}
+interface BleBridgeAdvertisingData {
+    randomAdvNumber: number[];
+    vinNum: number[];
+    macAddress: number[];
+    fwVersion?: string;
+    /**
+     * 0x01 - TYC New Security with development keys
+     * 0x02 - TYC New Security with production keys
+     * 0x10 - Krone New Security with development keys
+     * 0x11 - Krone New Security with production keys
+     * 0x00 - predecessors (old security)
+     */
+    configVersion: number;
+    timeFromStart?: number;
+}
+
+declare function createTirecheckDeviceSdk(bleImplementation: BleImplementation): {
+    bluetooth: {
+        onDeviceAdvertising(deviceAdvertisingCallback: (device: BleDevice) => void): void;
+        onDeviceUpdate(deviceUpdateCallback: (update: {
+            deviceId: string;
+            isConnected: boolean;
+        }) => void): void;
+        onDeviceUnreachable(deviceUnreachableCallback: (deviceId: string) => void): void;
+        scanDevices(services?: string[]): Promise<void>;
+    };
+};
+
+export { createTirecheckDeviceSdk };

package/dist/index.d.mts

@@ -0,0 +1,68 @@
+interface BleImplementation {
+    startScanWithOptions: (services: string[], options: StartScanOptions, success: (data: PeripheralData) => any, failure?: (error: string) => any) => void;
+    stopScan: () => Promise<void>;
+    /** Returns a resolved promise if the device is connected,
+    otherwise returns rejected promise if the device is not connected */
+    isConnected: ((deviceId: string) => Promise<void>) & ((deviceId: string, rejectWhenDisconnected: false) => Promise<boolean>);
+}
+interface StartScanOptions {
+    scanMode?: 'lowPower' | 'balanced' | 'lowLatency' | 'opportunistic';
+    callbackType?: 'all' | 'first' | 'lost';
+    matchMode?: 'aggressive' | 'sticky';
+    numOfMatches?: 'one' | 'few' | 'max';
+    phy?: '1m' | 'coded' | 'all';
+    legacy?: boolean;
+    reportDelay?: number;
+    forceScanFilter?: number;
+    reportDuplicates?: boolean;
+    /** Scanning duration in seconds */
+    duration?: number;
+}
+interface PeripheralData {
+    name: string;
+    id: string;
+    rssi: number;
+    advertising: ArrayBuffer | any;
+    connectable?: boolean;
+    state: PeripheralState;
+}
+type PeripheralState = 'disconnected' | 'disconnecting' | 'connecting' | 'connected';
+
+type BleDevice = BleBridge;
+interface BleBridge {
+    id: string;
+    name: string;
+    bridgeId: string;
+    vin: string;
+    advertisingData: BleBridgeAdvertisingData;
+    device: PeripheralData;
+}
+interface BleBridgeAdvertisingData {
+    randomAdvNumber: number[];
+    vinNum: number[];
+    macAddress: number[];
+    fwVersion?: string;
+    /**
+     * 0x01 - TYC New Security with development keys
+     * 0x02 - TYC New Security with production keys
+     * 0x10 - Krone New Security with development keys
+     * 0x11 - Krone New Security with production keys
+     * 0x00 - predecessors (old security)
+     */
+    configVersion: number;
+    timeFromStart?: number;
+}
+
+declare function createTirecheckDeviceSdk(bleImplementation: BleImplementation): {
+    bluetooth: {
+        onDeviceAdvertising(deviceAdvertisingCallback: (device: BleDevice) => void): void;
+        onDeviceUpdate(deviceUpdateCallback: (update: {
+            deviceId: string;
+            isConnected: boolean;
+        }) => void): void;
+        onDeviceUnreachable(deviceUnreachableCallback: (deviceId: string) => void): void;
+        scanDevices(services?: string[]): Promise<void>;
+    };
+};
+
+export { createTirecheckDeviceSdk };

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+interface BleImplementation {
+    startScanWithOptions: (services: string[], options: StartScanOptions, success: (data: PeripheralData) => any, failure?: (error: string) => any) => void;
+    stopScan: () => Promise<void>;
+    /** Returns a resolved promise if the device is connected,
+    otherwise returns rejected promise if the device is not connected */
+    isConnected: ((deviceId: string) => Promise<void>) & ((deviceId: string, rejectWhenDisconnected: false) => Promise<boolean>);
+}
+interface StartScanOptions {
+    scanMode?: 'lowPower' | 'balanced' | 'lowLatency' | 'opportunistic';
+    callbackType?: 'all' | 'first' | 'lost';
+    matchMode?: 'aggressive' | 'sticky';
+    numOfMatches?: 'one' | 'few' | 'max';
+    phy?: '1m' | 'coded' | 'all';
+    legacy?: boolean;
+    reportDelay?: number;
+    forceScanFilter?: number;
+    reportDuplicates?: boolean;
+    /** Scanning duration in seconds */
+    duration?: number;
+}
+interface PeripheralData {
+    name: string;
+    id: string;
+    rssi: number;
+    advertising: ArrayBuffer | any;
+    connectable?: boolean;
+    state: PeripheralState;
+}
+type PeripheralState = 'disconnected' | 'disconnecting' | 'connecting' | 'connected';
+
+type BleDevice = BleBridge;
+interface BleBridge {
+    id: string;
+    name: string;
+    bridgeId: string;
+    vin: string;
+    advertisingData: BleBridgeAdvertisingData;
+    device: PeripheralData;
+}
+interface BleBridgeAdvertisingData {
+    randomAdvNumber: number[];
+    vinNum: number[];
+    macAddress: number[];
+    fwVersion?: string;
+    /**
+     * 0x01 - TYC New Security with development keys
+     * 0x02 - TYC New Security with production keys
+     * 0x10 - Krone New Security with development keys
+     * 0x11 - Krone New Security with production keys
+     * 0x00 - predecessors (old security)
+     */
+    configVersion: number;
+    timeFromStart?: number;
+}
+
+declare function createTirecheckDeviceSdk(bleImplementation: BleImplementation): {
+    bluetooth: {
+        onDeviceAdvertising(deviceAdvertisingCallback: (device: BleDevice) => void): void;
+        onDeviceUpdate(deviceUpdateCallback: (update: {
+            deviceId: string;
+            isConnected: boolean;
+        }) => void): void;
+        onDeviceUnreachable(deviceUnreachableCallback: (deviceId: string) => void): void;
+        scanDevices(services?: string[]): Promise<void>;
+    };
+};
+
+export { createTirecheckDeviceSdk };

package/dist/index.mjs

@@ -0,0 +1,425 @@
+import _ from 'lodash';
+
+let ble;
+function setBleImplementation(bleImplementation) {
+  ble = bleImplementation;
+}
+
+const bridgeTools = {
+  //   convertBytesToStructure(objStructure: BridgeCommandStructureProperties, payload: number[]) {
+  //     const numArray = _.clone(payload)
+  //     const keys = Object.keys(objStructure)
+  //     const sumWithInitial = keys.reduce((accumulator, currentValue) => accumulator + objStructure[currentValue].size, 0)
+  //     if (numArray.length !== sumWithInitial) {
+  //       throw new Error('Cannot convert bytes to object')
+  //     }
+  //     const result: any = {}
+  //     for (const key of keys) {
+  //       const encodedData: number[] = numArray.splice(0, objStructure[key].size)
+  //       result[key] = this.decodeData(encodedData, objStructure[key].display)
+  //     }
+  //     return result
+  //   },
+  //   convertStructureToBytes(objStructure: any, structurizedObj: any) {
+  //     const keys = Object.keys(objStructure)
+  //     const result: number[] = []
+  //     for (const key of keys) {
+  //       const encoded = this.encodeData(structurizedObj[key], objStructure[key].display)
+  //       if (encoded.length < objStructure[key].size) {
+  //         const _padArray = Array.from({ length: objStructure[key].size - encoded.length }, () => 0)
+  //         encoded.push(..._padArray)
+  //       }
+  //       result.push(...encoded)
+  //     }
+  //     return result
+  //   },
+  //   convertAutoLearnObjectToBinary(data: Record<string, string>): Record<string, string> {
+  //     const result: Record<string, string> = {}
+  //     for (const key in data) {
+  //       if (!key.includes('axle')) continue
+  //       // Parse the value as hexadecimal (base 16)
+  //       const value = parseInt(data[key], 16)
+  //       // Convert to binary and pad with leading zeros to ensure 8 characters
+  //       const binaryString = value.toString(2).padStart(8, '0')
+  //       result[key] = binaryString
+  //     }
+  //     return result
+  //   },
+  //   decodeData(data: number[], displayUnits: undefined | 'ascii' | 'decimal') {
+  //     const _data = _.clone(data)
+  //     if (displayUnits === 'ascii') {
+  //       return _data
+  //         .filter(d => d)
+  //         .map(x => String.fromCharCode(x))
+  //         .join('')
+  //     }
+  //     const _reversedData = _data.reverse()
+  //     if (displayUnits === 'decimal') {
+  //       return Number(`0x${_reversedData.map(dec => this.decimalToHex(dec)).join('')}`.replace(/\r\n/g, ''))
+  //     }
+  //     return _reversedData.map(dec => this.decimalToHex(dec)).join('')
+  //   },
+  //   encodeData(data: number | string, displayUnits: undefined | 'ascii' | 'decimal'): number[] {
+  //     const _data = _.clone(data)
+  //     if (displayUnits === 'ascii') {
+  //       return (_data as string).split('').map((v, i) => (_data as string).charCodeAt(i))
+  //     }
+  //     if (displayUnits === 'decimal') {
+  //       return this.hexToDecimalArray(this.decimalToHex(_data as number)).reverse()
+  //     }
+  //     return this.hexToDecimalArray(_data as string).reverse()
+  //   },
+  //   getBridgeId(device: BluetoothDeviceBridge) {
+  //     // [244,177, 0, 34,123, 155] => F4B100227B9B
+  //     return (
+  //       device.advertisingData.macAddress
+  //         ?.map(n => this.decimalToHex(n))
+  //         .reverse()
+  //         .join('')
+  //         .toUpperCase() || ''
+  //     )
+  //   },
+  //   pkcs(array: any[], length: number) {
+  //     const pkcsValue = length - array.length
+  //     if (pkcsValue > 0) {
+  //       return [...array, ...new Array(pkcsValue).fill(pkcsValue)]
+  //     }
+  //     return array
+  //   },
+  decimalToHex(decimal) {
+    const hex = decimal.toString(16);
+    return hex.padStart(2, "0");
+  },
+  //   hexToDecimalArray(hex: string): number[] {
+  //     return hex.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) || []
+  //   },
+  getFwVersion(payload) {
+    if (payload?.length !== 3) {
+      console.warn("Could not process FwVersion ", payload);
+      return "";
+    }
+    return payload.reduce((acc, current) => {
+      const value = this.decimalToHex(current);
+      acc.push(value[0] === "0" ? value[1] : value);
+      return acc;
+    }, []).join(".");
+  }
+  //   barToKpaByte(value?: number) {
+  //     if (!value) return 0
+  //     return _.round(((value + 1) * 100) / 5.0625)
+  //   },
+  //   kpaByteToBar(value?: number, decrementValue = 1) {
+  //     if (!_.isNumber(value)) {
+  //       throw new TypeError('Value has to be a number')
+  //     }
+  //     const rawBar = (value * 5.0625) / 100
+  //     return Math.max(rawBar - decrementValue, 0)
+  //   },
+  //   getMacAddressIfOtaAndIos(device: BluetoothDeviceBridge) {
+  //     const uint8 = new Uint8Array(device.advertising.kCBAdvDataLeBluetoothDeviceAddress)
+  //     const macAddressArray = Array.from(uint8)
+  //       .reverse()
+  //       .slice(0, 6)
+  //       .map(x => this.decimalToHex(x).toUpperCase())
+  //     return macAddressArray.join('')
+  //   },
+  //   isVersionGreaterThan(version: string) {
+  //     if (version?.length !== 5) {
+  //       throw new Error('Invalid version format'.t())
+  //     }
+  //     if (bluetoothStore?.connectedBridge?.advertisingData?.fwVersion) {
+  //       return bluetoothStore?.connectedBridge?.advertisingData?.fwVersion > version
+  //     }
+  //     return false
+  //   },
+};
+
+const bridgeAdvertisingParser = {
+  getDeviceInfoFromAdvertising(device) {
+    const adversitingType = getAdvertisingType(device);
+    if (adversitingType !== "connectable")
+      return void 0;
+    const advertisingData = getAdvertisingData({ advertising: device.advertising, deviceName: device.name });
+    const bridgeId = advertisingData?.macAddress?.map((n) => bridgeTools.decimalToHex(n)).reverse().join("").toUpperCase() || "";
+    const vin = String.fromCharCode(...advertisingData?.vinNum || []).split("\0").join("");
+    return { id: device.id, name: device.name, bridgeId, vin, advertisingData, device };
+  }
+};
+function getAdvertisingType(device) {
+  if (device.advertising?.kCBAdvDataIsConnectable) {
+    return "connectable";
+  }
+  const numberArray = Array.from(new Uint8Array(device.advertising));
+  if (_.isEqual(numberArray.slice(0, 4), [2, 1, 6, 7])) {
+    return "connectable";
+  }
+  if (numberArray[3] === 26) {
+    return "krone";
+  }
+  if (_.isEqual(numberArray.slice(0, 4), [2, 1, 6, 3])) {
+    return "measurement";
+  }
+  return "unknown";
+}
+function getAdvertisingData({ advertising, deviceName }) {
+  const isKrone = deviceName === "030321";
+  const uint8 = new Uint8Array(
+    advertising.kCBAdvDataIsConnectable ? advertising.kCBAdvDataManufacturerData : advertising
+  );
+  const adv = Array.from(uint8);
+  const advertisingData = advertising.kCBAdvDataIsConnectable ? processIosAdvertising(adv) : processAndroidAdvertising(adv, isKrone);
+  if (!advertisingData || !advertisingData.macAddress.length || !advertisingData.randomAdvNumber.length || !advertisingData.vinNum.length) {
+    throw new Error("Device not recognized");
+  }
+  return advertisingData;
+}
+function processAndroidAdvertising(adv, isKrone) {
+  const advertisingData = {
+    configVersion: isKrone ? 17 : 1,
+    macAddress: [],
+    randomAdvNumber: [],
+    vinNum: [],
+    fwVersion: void 0,
+    timeFromStart: void 0
+  };
+  do {
+    const length = adv[0];
+    const identificator = adv[1];
+    const messageType = adv[4];
+    const packet = adv.splice(0, length + 1);
+    if (!length) {
+      adv = [];
+    }
+    if (messageType === 3 && identificator === 255) {
+      advertisingData.macAddress = packet.slice(5, 11);
+      advertisingData.vinNum = packet.slice(-17);
+    }
+    if (messageType === 1 && identificator === 255) {
+      advertisingData.randomAdvNumber = packet.slice(-8);
+    }
+    if (messageType === 4 && identificator === 255) {
+      advertisingData.randomAdvNumber = packet.slice(5, 13);
+      advertisingData.fwVersion = bridgeTools.getFwVersion(packet.slice(13, 16));
+      advertisingData.configVersion = packet[16];
+      advertisingData.timeFromStart = packet[17];
+    }
+  } while (adv.length);
+  return advertisingData;
+}
+function processIosAdvertising(adv, isKrone) {
+  if (adv.length < 34)
+    return void 0;
+  if (adv.length === 35) {
+    adv.slice(3, 11);
+    adv.slice(12, 18);
+    adv.slice(18, 35);
+  }
+  if (adv.length === 40) {
+    adv.slice(3, 11);
+    bridgeTools.getFwVersion(adv.slice(11, 14));
+    adv[14];
+    adv[15];
+    adv.slice(17, 23);
+    adv.slice(23, 40);
+  }
+}
+
+const deviceMeta = {
+  bridge: {
+    nameRegex: /(030303|030321)/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      // message from device
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
+    },
+    capabilities: [],
+    manufacturerId: 2978,
+    mtu: 256,
+    getDeviceInfoFromAdvertising: bridgeAdvertisingParser.getDeviceInfoFromAdvertising
+  },
+  bridgeOta: {
+    nameRegex: /CAN BLE BRDG OTA.*/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d7"
+    },
+    capabilities: [],
+    getDeviceInfoFromAdvertising: () => {
+    }
+  },
+  flexiGaugeTpms: {
+    nameRegex: /Flexi.*/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      // message from device
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
+    },
+    getDeviceInfoFromAdvertising: () => {
+    },
+    // Do we need it here?
+    capabilities: [
+      {
+        id: "td",
+        // processFn: processTreadDepth,
+        regex: /^\*TD.*/
+      },
+      {
+        id: "button",
+        // processFn: processButtonPress,
+        regex: /^\*[UDLRC] $/
+      },
+      {
+        id: "tpms",
+        // processFn: processTpms,
+        regex: /^\*TPMS.*/
+      }
+    ],
+    reconnect: true
+    // Do we need it here?
+  },
+  pressureStick: {
+    nameRegex: /Pressure Stick.*/,
+    characteristic: {
+      serviceId: "4880c12c-fdcb-4077-8920-a450d7f9b907",
+      characteristicId: "fec26ec4-6d71-4442-9f81-55bc21d658d6"
+    },
+    getDeviceInfoFromAdvertising: () => {
+    },
+    capabilities: [
+      {
+        id: "pressure",
+        // processFn: processPressure,
+        regex: /P([0-9.]+)mBar/
+      }
+      // only pressure is needed for initial implementation, uncomment tpms functionality when needed
+      // {
+      //   id: 'tpms',
+      //   processFn: processTpms,
+      //   regex: /^\*TPMS/,
+      // },
+    ]
+  }
+};
+
+const checkUnreachableDevicesTimeouts = {};
+const checkConnectedStateIntervals = {};
+const deviceAdvertisingCallbacks = [];
+const deviceUpdateCallbacks = [];
+const deviceUnreachableCallbacks = [];
+const bluetooth = {
+  /** Triggered when "scanDevices" detects device supported by SDK */
+  onDeviceAdvertising(deviceAdvertisingCallback) {
+    deviceAdvertisingCallbacks.push(deviceAdvertisingCallback);
+  },
+  onDeviceUpdate(deviceUpdateCallback) {
+    deviceUpdateCallbacks.push(deviceUpdateCallback);
+  },
+  onDeviceUnreachable(deviceUnreachableCallback) {
+    deviceUnreachableCallbacks.push(deviceUnreachableCallback);
+  },
+  async scanDevices(services = []) {
+    await ble.stopScan();
+    ble.startScanWithOptions(
+      services,
+      {
+        reportDuplicates: true,
+        matchMode: "aggressive",
+        scanMode: "lowLatency",
+        numOfMatches: "max",
+        callbackType: "all",
+        reportDelay: 0
+      },
+      (device) => {
+        const processedDevice = processDevice(device);
+        if (!processedDevice)
+          return;
+        for (const c of deviceAdvertisingCallbacks) {
+          c(processedDevice);
+        }
+      },
+      (e) => console.error("ble.startScanWithOptions error:", e)
+    );
+  }
+};
+function processDevice(device) {
+  const uint8 = new Uint8Array(device.advertising);
+  const adv = Array.from(uint8);
+  let name = device.advertising.kCBAdvDataLocalName || device.name;
+  if (!name || name === "OTA") {
+    name = getDeviceNameFromAdvertising(adv);
+  }
+  const deviceType = getDeviceTypeFromName(name);
+  if (!deviceType) {
+    return;
+  }
+  let processedDevice;
+  try {
+    processedDevice = deviceMeta[deviceType].getDeviceInfoFromAdvertising({ ...device, name });
+    if (!processedDevice)
+      return;
+  } catch (e) {
+    console.warn("Error processing advertising", e);
+    return;
+  }
+  refreshUnreachableTimeouts(processedDevice.id);
+  monitorConnectedState(processedDevice.id);
+  return processedDevice;
+}
+function getDeviceTypeFromName(name) {
+  let deviceType;
+  for (const key in deviceMeta) {
+    const meta = deviceMeta[key];
+    if (meta.nameRegex.test(name)) {
+      deviceType = key;
+    }
+  }
+  return deviceType;
+}
+function monitorConnectedState(deviceId) {
+  if (checkConnectedStateIntervals[deviceId])
+    return;
+  checkConnectedStateIntervals[deviceId] = setInterval(async () => {
+    let isConnected = false;
+    try {
+      await ble.isConnected(deviceId);
+      isConnected = true;
+    } catch {
+      isConnected = false;
+    }
+    for (const c of deviceUpdateCallbacks) {
+      c({ deviceId, isConnected });
+    }
+  }, 1e3);
+}
+function refreshUnreachableTimeouts(deviceId) {
+  if (checkUnreachableDevicesTimeouts[deviceId]) {
+    clearTimeout(checkUnreachableDevicesTimeouts[deviceId]);
+  }
+  checkUnreachableDevicesTimeouts[deviceId] = setTimeout(() => {
+    for (const c of deviceUnreachableCallbacks) {
+      c(deviceId);
+    }
+    if (checkConnectedStateIntervals[deviceId]) {
+      clearInterval(checkConnectedStateIntervals[deviceId]);
+      delete checkConnectedStateIntervals[deviceId];
+    }
+  }, 6e4);
+}
+function getDeviceNameFromAdvertising(adv) {
+  const advertising = _.clone(adv);
+  const messageType = advertising[4];
+  const packet = advertising.slice(5, 11);
+  if (messageType === 9) {
+    return packet.map((x) => String.fromCharCode(x)).join("");
+  }
+  return "";
+}
+
+function createTirecheckDeviceSdk(bleImplementation) {
+  setBleImplementation(bleImplementation);
+  return {
+    bluetooth
+  };
+}
+
+export { createTirecheckDeviceSdk };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "tirecheck-device-sdk",
+  "version": "0.1.0",
+  "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",
+  "keywords": [],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^2.25.1",
+    "@types/lodash": "^4.17.7",
+    "@vitest/ui": "^2.0.5",
+    "eslint": "^9.9.0",
+    "eslint-plugin-format": "^0.1.2",
+    "eslint-plugin-tyrecheck": "^2.64.0",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.0.5"
+  },
+  "scripts": {
+    "test": "vitest --ui",
+    "dev": "pnpm install && vitest --ui",
+    "build": "unbuild"
+  }
+}