incyclist-devices 2.2.9 → 2.3.0

package/lib/direct-connect/messages/DiscoverServices.d.ts

@@ -0,0 +1,15 @@
+import { EmptyBody, TDCBody, TDCMessageHeader, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCDiscoverServicesRequest = TDCRequest<EmptyBody>;
+export type TDCDiscoverServicesResponse = TDCResponse<TDCDiscoverServicesResponseBody>;
+export interface TDCDiscoverServicesResponseBody extends TDCBody {
+    serviceDefinitions: Array<{
+        serviceUUID: string;
+    }>;
+}
+export declare class DiscoverServiceMessage extends Message<EmptyBody, TDCDiscoverServicesResponseBody> {
+    constructor();
+    buildResponseBody(body: TDCDiscoverServicesResponseBody): Buffer;
+    parseResponseBody(body: Buffer): TDCDiscoverServicesResponseBody;
+    verifyHeader(header: TDCMessageHeader): boolean;
+}

package/lib/direct-connect/messages/DiscoverServices.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoverServiceMessage = void 0;
+const consts_1 = require("../consts");
+const error_1 = require("./error");
+const message_1 = require("./message");
+class DiscoverServiceMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_DISCOVER_SERVICES);
+    }
+    buildResponseBody(body) {
+        const serviceBuffers = body.serviceDefinitions.map((service) => {
+            return Buffer.from(service.serviceUUID, "hex");
+        });
+        return Buffer.concat(serviceBuffers);
+    }
+    parseResponseBody(body) {
+        const serviceDefinitions = [];
+        const length = body.length;
+        for (let i = 0; i < length; i += 16) {
+            const serviceUUID = body.subarray(i, i + 16).toString("hex");
+            serviceDefinitions.push({ serviceUUID });
+        }
+        return { serviceDefinitions };
+    }
+    verifyHeader(header) {
+        if (header.msgId !== consts_1.DC_MESSAGE_DISCOVER_SERVICES) {
+            throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_TYPE);
+        }
+        return super.verifyHeader(header);
+    }
+}
+exports.DiscoverServiceMessage = DiscoverServiceMessage;

package/lib/direct-connect/messages/EnableCharacteristicNotifications.d.ts

@@ -0,0 +1,18 @@
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCEnableCharacteristicNotificationsRequest = TDCRequest<TDCEnableCharacteristicNotificationsRequestBody>;
+export type TDCEnableCharacteristicNotificationsResponse = TDCResponse<TDCEnableCharacteristicNotificationsResponseBody>;
+export interface TDCEnableCharacteristicNotificationsRequestBody extends TDCBody {
+    characteristicUUID: string;
+    enable: boolean;
+}
+export interface TDCEnableCharacteristicNotificationsResponseBody extends TDCBody {
+    characteristicUUID: string;
+}
+export declare class EnableCharacteristicNotificationsMessage extends Message<TDCEnableCharacteristicNotificationsRequestBody, TDCEnableCharacteristicNotificationsResponseBody> {
+    constructor();
+    buildRequestBody(body: TDCEnableCharacteristicNotificationsRequestBody): Buffer;
+    buildResponseBody(body: TDCEnableCharacteristicNotificationsResponseBody): Buffer;
+    parseRequestBody(body: Buffer): TDCEnableCharacteristicNotificationsRequestBody;
+    parseResponseBody(body: Buffer): TDCEnableCharacteristicNotificationsResponseBody;
+}

package/lib/direct-connect/messages/EnableCharacteristicNotifications.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnableCharacteristicNotificationsMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class EnableCharacteristicNotificationsMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS);
+    }
+    buildRequestBody(body) {
+        const enabledVal = body.enable ? 1 : 0;
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from([enabledVal])
+        ]);
+    }
+    buildResponseBody(body) {
+        return Buffer.from(body.characteristicUUID, "hex");
+    }
+    parseRequestBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const enabledVal = body.readUInt8(16);
+        const enable = enabledVal !== 0;
+        return {
+            characteristicUUID, enable
+        };
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        return {
+            characteristicUUID,
+        };
+    }
+}
+exports.EnableCharacteristicNotificationsMessage = EnableCharacteristicNotificationsMessage;

package/lib/direct-connect/messages/ReadCharacteristic.d.ts

@@ -0,0 +1,18 @@
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCReadCharacteristicRequest = TDCRequest<TDCReadCharacteristicRequestBody>;
+export type TDCReadCharacteristicResponse = TDCResponse<TDCReadCharacteristicResponseBody>;
+export interface TDCReadCharacteristicRequestBody extends TDCBody {
+    characteristicUUID: string;
+}
+export interface TDCReadCharacteristicResponseBody extends TDCBody {
+    characteristicUUID: string;
+    characteristicData: Uint8Array;
+}
+export declare class ReadCharacteristicMessage extends Message<TDCReadCharacteristicRequestBody, TDCReadCharacteristicResponseBody> {
+    constructor();
+    buildRequestBody(body: TDCReadCharacteristicRequestBody): Buffer;
+    buildResponseBody(body: TDCReadCharacteristicResponseBody): Buffer;
+    parseRequestBody(body: Buffer): TDCReadCharacteristicRequestBody;
+    parseResponseBody(body: Buffer): TDCReadCharacteristicResponseBody;
+}

package/lib/direct-connect/messages/ReadCharacteristic.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadCharacteristicMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class ReadCharacteristicMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_READ_CHARACTERISTIC);
+    }
+    buildRequestBody(body) {
+        return Buffer.from(body.characteristicUUID, "hex");
+    }
+    buildResponseBody(body) {
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from(body.characteristicData),
+        ]);
+    }
+    parseRequestBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        return {
+            characteristicUUID,
+        };
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const characteristicData = body.subarray(16, body.length);
+        return {
+            characteristicUUID,
+            characteristicData,
+        };
+    }
+}
+exports.ReadCharacteristicMessage = ReadCharacteristicMessage;

package/lib/direct-connect/messages/WriteCharacteristic.d.ts

@@ -0,0 +1,18 @@
+import { TDCBody, TDCRequest, TDCResponse } from "../types";
+import { Message } from "./message";
+export type TDCWriteCharacteristicRequest = TDCRequest<TDCWriteCharacteristicRequestBody>;
+export type TDCWriteCharacteristicResponse = TDCResponse<TDCWriteCharacteristicResponseBody>;
+export interface TDCWriteCharacteristicRequestBody extends TDCBody {
+    characteristicUUID: string;
+    characteristicData: Uint8Array;
+}
+export interface TDCWriteCharacteristicResponseBody extends TDCBody {
+    characteristicUUID: string;
+}
+export declare class WriteCharacteristicMessage extends Message<TDCWriteCharacteristicRequestBody, TDCWriteCharacteristicResponseBody> {
+    constructor();
+    buildRequestBody(body: TDCWriteCharacteristicRequestBody): Buffer;
+    buildResponseBody(body: TDCWriteCharacteristicResponseBody): Buffer;
+    parseRequestBody(body: Buffer): TDCWriteCharacteristicRequestBody;
+    parseResponseBody(body: Buffer): TDCWriteCharacteristicResponseBody;
+}

package/lib/direct-connect/messages/WriteCharacteristic.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteCharacteristicMessage = void 0;
+const consts_1 = require("../consts");
+const message_1 = require("./message");
+class WriteCharacteristicMessage extends message_1.Message {
+    constructor() {
+        super(consts_1.DC_MESSAGE_WRITE_CHARACTERISTIC);
+    }
+    buildRequestBody(body) {
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+            Buffer.from(body.characteristicData),
+        ]);
+    }
+    buildResponseBody(body) {
+        return Buffer.concat([
+            Buffer.from(body.characteristicUUID, "hex"),
+        ]);
+    }
+    parseRequestBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        const characteristicData = body.subarray(16, body.length);
+        return {
+            characteristicUUID,
+            characteristicData,
+        };
+    }
+    parseResponseBody(body) {
+        const characteristicUUID = Buffer.from(body.subarray(0, 16)).toString("hex");
+        return {
+            characteristicUUID,
+        };
+    }
+}
+exports.WriteCharacteristicMessage = WriteCharacteristicMessage;

package/lib/direct-connect/messages/error.d.ts

@@ -0,0 +1,5 @@
+export declare class IllegalMessageError extends Error {
+    code: number;
+    constructor(code: number);
+}
+export declare const getResponseCode: (error: IllegalMessageError) => number;

package/lib/direct-connect/messages/error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResponseCode = exports.IllegalMessageError = void 0;
+const consts_1 = require("../consts");
+class IllegalMessageError extends Error {
+    constructor(code) {
+        super('Illegal request: ' + code);
+        this.code = code;
+        this.name = 'IllegalRequestError';
+    }
+}
+exports.IllegalMessageError = IllegalMessageError;
+const getResponseCode = (error) => {
+    if (error.code === consts_1.DC_ERROR_UNKNOWN_MESSAGE_TYPE)
+        return consts_1.DC_RC_UNKNOWN_MESSAGE_TYPE;
+    return consts_1.DC_RC_UNEXPECTED_ERROR;
+};
+exports.getResponseCode = getResponseCode;

package/lib/direct-connect/messages/factory.d.ts

@@ -0,0 +1,6 @@
+import { Message } from "./message";
+export declare class DCMessageFactory {
+    static createMessage(buffer: Buffer): Message<any, any>;
+    static create(msgId: number): Message<any, any>;
+    static buildErrorResponse(request: Buffer, code: number): Buffer;
+}

package/lib/direct-connect/messages/factory.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DCMessageFactory = void 0;
+const consts_1 = require("../consts");
+const CharacteristicNotification_1 = require("./CharacteristicNotification");
+const DiscoverCharacteristics_1 = require("./DiscoverCharacteristics");
+const DiscoverServices_1 = require("./DiscoverServices");
+const EnableCharacteristicNotifications_1 = require("./EnableCharacteristicNotifications");
+const error_1 = require("./error");
+const ReadCharacteristic_1 = require("./ReadCharacteristic");
+const WriteCharacteristic_1 = require("./WriteCharacteristic");
+class DCMessageFactory {
+    static createMessage(buffer) {
+        if (buffer.length < 6) {
+            throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_LENGTH);
+        }
+        const msgId = buffer.readUInt8(1);
+        return this.create(msgId);
+    }
+    static create(msgId) {
+        switch (msgId) {
+            case consts_1.DC_MESSAGE_DISCOVER_SERVICES:
+                return new DiscoverServices_1.DiscoverServiceMessage();
+            case consts_1.DC_MESSAGE_DISCOVER_CHARACTERISTICS:
+                return new DiscoverCharacteristics_1.DiscoverCharacteristicsMessage();
+            case consts_1.DC_MESSAGE_READ_CHARACTERISTIC:
+                return new ReadCharacteristic_1.ReadCharacteristicMessage();
+            case consts_1.DC_MESSAGE_WRITE_CHARACTERISTIC:
+                return new WriteCharacteristic_1.WriteCharacteristicMessage();
+            case consts_1.DC_MESSAGE_ENABLE_CHARACTERISTIC_NOTIFICATIONS:
+                return new EnableCharacteristicNotifications_1.EnableCharacteristicNotificationsMessage();
+            case consts_1.DC_MESSAGE_CHARACTERISTIC_NOTIFICATION:
+                return new CharacteristicNotification_1.CharacteristicNotificationMessage();
+            default:
+                throw new error_1.IllegalMessageError(consts_1.DC_ERROR_UNKNOWN_MESSAGE_TYPE);
+        }
+    }
+    static buildErrorResponse(request, code) {
+        const response = Buffer.from(request);
+        response.writeUInt8(code, 3);
+        return response;
+    }
+}
+exports.DCMessageFactory = DCMessageFactory;

package/lib/direct-connect/messages/index.d.ts

@@ -0,0 +1,9 @@
+export * from './error';
+export * from './message';
+export * from './factory';
+export * from './DiscoverServices';
+export * from './DiscoverCharacteristics';
+export * from './ReadCharacteristic';
+export * from './WriteCharacteristic';
+export * from './EnableCharacteristicNotifications';
+export * from './CharacteristicNotification';

package/lib/direct-connect/messages/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./error"), exports);
+__exportStar(require("./message"), exports);
+__exportStar(require("./factory"), exports);
+__exportStar(require("./DiscoverServices"), exports);
+__exportStar(require("./DiscoverCharacteristics"), exports);
+__exportStar(require("./ReadCharacteristic"), exports);
+__exportStar(require("./WriteCharacteristic"), exports);
+__exportStar(require("./EnableCharacteristicNotifications"), exports);
+__exportStar(require("./CharacteristicNotification"), exports);

package/lib/direct-connect/messages/message.d.ts

@@ -0,0 +1,20 @@
+import { TDCBody, TDCMessageHeader, TDCRequest, TDCResponse } from "../types";
+export declare class Message<TReq extends TDCBody, TRes extends TDCBody> {
+    msgId?: number;
+    protected request: TDCRequest<TReq>;
+    protected response: TDCResponse<TRes>;
+    constructor(msgId?: number);
+    buildResponse(response: TDCResponse<TRes>): Buffer;
+    buildRequest(request: TDCRequest<TReq>): Buffer;
+    createRequest(seqNum: any, body: TReq): Buffer;
+    parseRequest(buffer: Buffer): TDCRequest<TReq>;
+    prepareResponse(request: TDCRequest<TReq>, respCode: number, body: TRes): TDCResponse<TRes>;
+    parseResponse(buffer: Buffer): TDCResponse<TRes>;
+    buildHeader(header: TDCMessageHeader, length: number): Buffer;
+    buildResponseBody(body: TRes): Buffer;
+    buildRequestBody(body: TReq): Buffer;
+    verifyHeader(header: TDCMessageHeader): boolean;
+    parseRequestBody(body: Buffer): TReq;
+    parseResponseBody(body: Buffer): TRes;
+}
+export declare const parseHeader: (buffer: Buffer) => TDCMessageHeader;

package/lib/direct-connect/messages/message.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHeader = exports.Message = void 0;
+const consts_1 = require("../consts");
+const error_1 = require("./error");
+class Message {
+    constructor(msgId) {
+        this.msgId = msgId;
+    }
+    buildResponse(response) {
+        const { header, body } = response;
+        const bodyBuffer = this.buildResponseBody(body);
+        const headerBuffer = this.buildHeader(header, bodyBuffer.length);
+        return Buffer.concat([headerBuffer, bodyBuffer]);
+    }
+    buildRequest(request) {
+        const { header, body } = request;
+        const bodyBuffer = this.buildRequestBody(body);
+        const headerBuffer = this.buildHeader(header, bodyBuffer.length);
+        return Buffer.concat([headerBuffer, bodyBuffer]);
+    }
+    createRequest(seqNum, body) {
+        const header = {
+            msgId: this.msgId,
+            seqNum,
+            respCode: 0,
+            msgVersion: 1,
+            length: 0
+        };
+        return this.buildRequest({ header, body });
+    }
+    parseRequest(buffer) {
+        const header = (0, exports.parseHeader)(buffer);
+        this.verifyHeader(header);
+        const bodyBuffer = buffer.subarray(6);
+        const body = this.parseRequestBody(bodyBuffer);
+        return { header, body };
+    }
+    prepareResponse(request, respCode, body) {
+        const header = Object.assign(Object.assign({}, request.header), { respCode });
+        return { header, body };
+    }
+    parseResponse(buffer) {
+        const header = (0, exports.parseHeader)(buffer);
+        this.verifyHeader(header);
+        const bodyBuffer = buffer.subarray(6);
+        const body = this.parseResponseBody(bodyBuffer);
+        return { header, body };
+    }
+    buildHeader(header, length) {
+        const buffer = Buffer.alloc(6);
+        buffer.writeUInt8(header.msgVersion, 0);
+        buffer.writeUInt8(header.msgId, 1);
+        buffer.writeUInt8(header.seqNum, 2);
+        buffer.writeUInt8(header.respCode, 3);
+        buffer.writeUInt16BE(length !== null && length !== void 0 ? length : header.length, 4);
+        return buffer;
+    }
+    buildResponseBody(body) {
+        return Buffer.from([]);
+    }
+    buildRequestBody(body) {
+        return Buffer.from([]);
+    }
+    verifyHeader(header) {
+        if (header.msgId !== this.msgId) {
+            throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_TYPE);
+        }
+        return true;
+    }
+    parseRequestBody(body) {
+        return {};
+    }
+    parseResponseBody(body) {
+        return {};
+    }
+}
+exports.Message = Message;
+const parseHeader = (buffer) => {
+    if (buffer.length < 6) {
+        throw new error_1.IllegalMessageError(consts_1.DC_ERROR_INVALID_MESSAGE_LENGTH);
+    }
+    const msgVersion = buffer.readUInt8(0);
+    const msgId = buffer.readUInt8(1);
+    const seqNum = buffer.readUInt8(2);
+    const respCode = buffer.readUInt8(3);
+    const length = buffer.readUInt16BE(4);
+    return { msgVersion, msgId, seqNum, respCode, length };
+};
+exports.parseHeader = parseHeader;

package/lib/direct-connect/types.d.ts

@@ -0,0 +1,24 @@
+import { IncyclistScanProps } from "../types";
+export interface TDCMessageHeader {
+    msgVersion: number;
+    msgId: number;
+    seqNum: number;
+    respCode: number;
+    length: number;
+}
+export interface TDCBody {
+}
+export declare class TDCRequest<T extends TDCBody> {
+    header: TDCMessageHeader;
+    body: T;
+}
+export declare class TDCResponse<T extends TDCBody> {
+    header: TDCMessageHeader;
+    body: T;
+}
+export interface EmptyBody extends TDCBody {
+}
+export interface DirectConnectScanProps extends IncyclistScanProps {
+    serviceUUID?: string;
+    serviceUUIDs?: string[];
+}

package/lib/direct-connect/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TDCResponse = exports.TDCRequest = void 0;
+class TDCRequest {
+}
+exports.TDCRequest = TDCRequest;
+class TDCResponse {
+}
+exports.TDCResponse = TDCResponse;

package/lib/direct-connect/utils.d.ts

@@ -0,0 +1,5 @@
+import { BleProperty } from "../ble/types";
+export declare const parseUUID: (str: string) => string;
+export declare const beautifyUUID: (str: string, withX?: boolean) => string;
+export declare const propertyVal: (properties: BleProperty[]) => number;
+export declare const propertyFromVal: (val: number) => BleProperty[];

package/lib/direct-connect/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyFromVal = exports.propertyVal = exports.beautifyUUID = exports.parseUUID = void 0;
+const parseUUID = (str) => {
+    const uuid = str.toUpperCase();
+    if (str.startsWith('0x')) {
+        const hex = uuid.slice(2);
+        if (hex.length === 4) {
+            return `0000${hex}00001000800000805F9B34FB`;
+        }
+        if (hex.length === 8) {
+            return `${hex}00001000800000805F9B34FB`;
+        }
+    }
+    else if (uuid.length === 4) {
+        return `0000${uuid}00001000800000805F9B34FB`;
+    }
+    else if (uuid.length === 8) {
+        return `${uuid}00001000800000805F9B34FB`;
+    }
+    else if (uuid.length === 32) {
+        return uuid;
+    }
+    else if (uuid.length === 36) {
+        return uuid.replace(/-/g, '');
+    }
+    throw new Error(`Invalid UUID: ${uuid}`);
+};
+exports.parseUUID = parseUUID;
+const beautifyUUID = (str, withX = false) => {
+    const uuid = (0, exports.parseUUID)(str);
+    const parts = [
+        uuid.substring(0, 8),
+        uuid.substring(8, 12),
+        uuid.substring(12, 16),
+        uuid.substring(16, 20),
+        uuid.substring(20),
+    ];
+    if (uuid.substring(8) === '00001000800000805F9B34FB') {
+        let short;
+        if (parts[0].startsWith('0000')) {
+            short = parts[0].substring(4);
+        }
+        else {
+            short = parts[0];
+        }
+        return withX ? `0x${short}` : short;
+    }
+    return parts.join('-');
+};
+exports.beautifyUUID = beautifyUUID;
+const propertyVal = (properties) => {
+    let res = 0;
+    if (properties.includes('read'))
+        res |= 0x01;
+    if (properties.includes('write'))
+        res |= 0x02;
+    if (properties.includes('notify'))
+        res |= 0x04;
+    return res;
+};
+exports.propertyVal = propertyVal;
+const propertyFromVal = (val) => {
+    const res = [];
+    if (val & 0x01)
+        res.push('read');
+    if (val & 0x02)
+        res.push('write');
+    if (val & 0x04)
+        res.push('notify');
+    return res;
+};
+exports.propertyFromVal = propertyFromVal;

package/lib/factories/adapters.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const antv2_1 = require("../antv2");
+const adapter_factory_1 = __importDefault(require("../antv2/factories/adapter-factory"));
 const ble_1 = require("../ble");
 const serial_1 = require("../serial");
 const Simulator_1 = require("../simulator/Simulator");
@@ -8,7 +11,8 @@ const device_1 = require("../types/device");
 class AdapterFactory {
     static reset() {
         AdapterFactory.adapters = [];
-        ble_1.BleAdapterFactory.getInstance().instances = [];
+        ble_1.BleAdapterFactory.getInstance('ble').instances = [];
+        ble_1.BleAdapterFactory.getInstance('wifi').instances = [];
     }
     static create(settings, props) {
         const adapters = AdapterFactory.adapters;
@@ -23,6 +27,7 @@ class AdapterFactory {
         if (existing)
             return existing;
         const ifaceName = typeof settings.interface === 'string' ? settings.interface : settings.interface.getName();
+        console.log(`creating adapter for ${ifaceName}`);
         let adapter;
         switch (ifaceName) {
             case device_1.INTERFACE.SERIAL:
@@ -30,10 +35,17 @@ class AdapterFactory {
                 adapter = serial_1.SerialAdapterFactory.getInstance().createInstance(settings, props);
                 break;
             case device_1.INTERFACE.ANT:
-                adapter = antv2_1.AntAdapterFactory.getInstance().createInstance(settings, props);
+                adapter = adapter_factory_1.default.getInstance().createInstance(settings, props);
                 break;
             case device_1.INTERFACE.BLE:
-                adapter = ble_1.BleAdapterFactory.getInstance().createInstance(settings, props);
+                adapter = ble_1.BleAdapterFactory.getInstance('ble').createInstance(settings, props);
+                break;
+            case device_1.INTERFACE.DC:
+                {
+                    const factory = ble_1.BleAdapterFactory.getInstance('wifi');
+                    console.log('creating wifi adapter for direct connect', factory);
+                    adapter = ble_1.BleAdapterFactory.getInstance('wifi').createInstance(settings, props);
+                }
                 break;
             case device_1.INTERFACE.SIMULATOR:
                 adapter = new Simulator_1.Simulator(settings, props);

package/lib/factories/interfaces.d.ts

@@ -2,6 +2,7 @@ import { InterfaceProps } from "../types/interface";
 import { SerialInterface } from "../serial";
 import AntInterface from "../antv2/base/interface";
 import { BleInterface } from "../ble";
+import DirectConnectInterface from "../direct-connect/base/interface";
 export default class InterfaceFactory {
-    static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface;
+    static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface | DirectConnectInterface;
 }

package/lib/factories/interfaces.js

@@ -7,20 +7,23 @@ const serial_1 = require("../serial");
 const interface_1 = __importDefault(require("../antv2/base/interface"));
 const device_1 = require("../types/device");
 const ble_1 = require("../ble");
+const interface_2 = __importDefault(require("../direct-connect/base/interface"));
 class InterfaceFactory {
     static create(ifaceName, props) {
         switch (ifaceName) {
             case device_1.INTERFACE.SERIAL:
             case device_1.INTERFACE.TCPIP:
-                const serialProps = (props || {});
-                serialProps.ifaceName = ifaceName;
-                return serial_1.SerialInterface.getInstance(serialProps);
+                {
+                    const serialProps = (props || {});
+                    serialProps.ifaceName = ifaceName;
+                    return serial_1.SerialInterface.getInstance(serialProps);
+                }
             case device_1.INTERFACE.ANT:
-                const antProps = props;
-                return interface_1.default.getInstance(antProps);
+                return interface_1.default.getInstance(props);
             case device_1.INTERFACE.BLE:
-                const bleProps = props;
-                return ble_1.BleInterface.getInstance(bleProps);
+                return ble_1.BleInterface.getInstance(props);
+            case device_1.INTERFACE.DC:
+                return interface_2.default.getInstance(props);
         }
     }
 }